1 using System;
    2 using System.Collections;
    3 using System.Text.Parsing;
    4 
    5 // this source file has been automatically generated from 'IntermediateCodeFileGrammar.parser' using cmparsergen version 2.0.0.
    6 
    7 namespace cmsx.intermediate
    8 {
    9     public class IntermediateCodeFileGrammar : System.Text.Parsing.Grammar
   10     {
   11         public IntermediateCodeFileGrammar() : this(new ParsingDomain())
   12         {
   13         }
   14         public IntermediateCodeFileGrammar(ParsingDomain* parsingDomain) : base(ToUtf32("IntermediateCodeFileGrammar"), parsingDomain->GetNamespaceScope(ToUtf32("cmsx.intermediate")), parsingDomain)
   15         {
   16             SetOwner(0);
   17             keywords0.Add(ToUtf32("void"));
   18             keywords0.Add(ToUtf32("byte"));
   19             keywords0.Add(ToUtf32("float"));
   20             keywords0.Add(ToUtf32("uint"));
   21             keywords0.Add(ToUtf32("bool"));
   22             keywords0.Add(ToUtf32("long"));
   23             keywords0.Add(ToUtf32("ushort"));
   24             keywords0.Add(ToUtf32("ulong"));
   25             keywords0.Add(ToUtf32("double"));
   26             keywords0.Add(ToUtf32("int"));
   27             keywords0.Add(ToUtf32("sbyte"));
   28             keywords0.Add(ToUtf32("short"));
   29             RegisterParsingDomain(parsingDomain);
   30             parsingDomain->AddGrammar(this);
   31             CreateRules();
   32             Link();
   33         }
   34         public void Parse(const uchar* start, const uchar* end, int fileIndex, const string& fileName, cmsx.intermediate.Context* context)
   35         {
   36             Scanner scanner(start, end, fileName, fileIndex, SkipRule());
   37             UniquePtr<XmlLog> xmlLog;
   38             if (Log() != null)
   39             {
   40                 xmlLog.Reset(new XmlLog(*Log(), MaxLogLineLength()));
   41                 scanner.SetLog(xmlLog.Get());
   42                 xmlLog->WriteBeginRule( u"parse");
   43                 xmlLog->IncIndent();
   44             }
   45             Stack<UniquePtr<Object>> stack;
   46             UniquePtr<ParsingData> parsingData(new ParsingData(Domain()->NumRules()));
   47             scanner.SetParsingData(parsingData.Get());
   48             stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context)));
   49             Match match = base->Parse(scanner, stack, parsingData.Get());
   50             Span stop = scanner.GetSpan();
   51             if (Log() != null)
   52             {
   53                 xmlLog->DecIndent();
   54                 xmlLog->WriteEndRule( u"parse");
   55             }
   56             if (!match.Hit() || stop.start != cast<int>(end - start))
   57             {
   58                 if (StartRule() != null)
   59                 {
   60                     throw ExpectationFailure(StartRule()->Info(), fileName, stop, start, end);
   61                 }
   62                 else
   63                 {
   64                     throw ParsingException("grammar '" + ToUtf8(Name()) + "' has no start rule", fileName, scanner.GetSpan(), start, end);
   65                 }
   66             }
   67         }
   68 
   69         public class IntermediateCodeFileRule : System.Text.Parsing.RuleParser
   70         {
   71             public IntermediateCodeFileRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
   72             {
   73                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
   74             }
   75             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
   76             {
   77                 parsingData->PushContext(Id(), new Context());
   78                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
   79                 UniquePtr<Object> context_value = stack.Pop();
   80                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
   81             }
   82             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
   83             {
   84                 parsingData->PopContext(Id());
   85             }
   86             public override void Link()
   87             {
   88                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
   89                 a0ActionParser->SetAction(A0Action);
   90                 NonterminalParser* typeDeclarationsNonterminalParser = GetNonterminal(ToUtf32("TypeDeclarations"));
   91                 typeDeclarationsNonterminalParser->SetPre(PreTypeDeclarations);
   92                 NonterminalParser* functionsNonterminalParser = GetNonterminal(ToUtf32("Functions"));
   93                 functionsNonterminalParser->SetPre(PreFunctions);
   94             }
   95             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
   96             {
   97                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
   98                 context->context->SetFileName(fileName);
   99             }
  100             public void PreTypeDeclarations(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  101             {
  102                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  103                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  104             }
  105             public void PreFunctions(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  106             {
  107                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  108                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  109             }
  110             public class Context : System.Text.Parsing.Context
  111             {
  112                 public Context() : context()
  113                 {
  114                 }
  115                 public cmsx.intermediate.Context* context;
  116             }
  117         }
  118 
  119         public class TypeDeclarationsRule : System.Text.Parsing.RuleParser
  120         {
  121             public TypeDeclarationsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  122             {
  123                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  124             }
  125             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  126             {
  127                 parsingData->PushContext(Id(), new Context());
  128                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  129                 UniquePtr<Object> context_value = stack.Pop();
  130                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  131             }
  132             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  133             {
  134                 parsingData->PopContext(Id());
  135             }
  136             public override void Link()
  137             {
  138                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  139                 a0ActionParser->SetAction(A0Action);
  140                 NonterminalParser* typeDeclarationNonterminalParser = GetNonterminal(ToUtf32("TypeDeclaration"));
  141                 typeDeclarationNonterminalParser->SetPre(PreTypeDeclaration);
  142             }
  143             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  144             {
  145                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  146                 context->context->ResolveTypes();
  147             }
  148             public void PreTypeDeclaration(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  149             {
  150                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  151                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  152             }
  153             public class Context : System.Text.Parsing.Context
  154             {
  155                 public Context() : context()
  156                 {
  157                 }
  158                 public cmsx.intermediate.Context* context;
  159             }
  160         }
  161 
  162         public class DataDefinitionsRule : System.Text.Parsing.RuleParser
  163         {
  164             public DataDefinitionsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  165             {
  166                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  167             }
  168             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  169             {
  170                 parsingData->PushContext(Id(), new Context());
  171                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  172                 UniquePtr<Object> context_value = stack.Pop();
  173                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  174             }
  175             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  176             {
  177                 parsingData->PopContext(Id());
  178             }
  179             public override void Link()
  180             {
  181                 NonterminalParser* dataDefinitionNonterminalParser = GetNonterminal(ToUtf32("DataDefinition"));
  182                 dataDefinitionNonterminalParser->SetPre(PreDataDefinition);
  183             }
  184             public void PreDataDefinition(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  185             {
  186                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  187                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  188             }
  189             public class Context : System.Text.Parsing.Context
  190             {
  191                 public Context() : context()
  192                 {
  193                 }
  194                 public cmsx.intermediate.Context* context;
  195             }
  196         }
  197 
  198         public class FunctionsRule : System.Text.Parsing.RuleParser
  199         {
  200             public FunctionsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  201             {
  202                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  203             }
  204             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  205             {
  206                 parsingData->PushContext(Id(), new Context());
  207                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  208                 UniquePtr<Object> context_value = stack.Pop();
  209                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  210             }
  211             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  212             {
  213                 parsingData->PopContext(Id());
  214             }
  215             public override void Link()
  216             {
  217                 NonterminalParser* functionNonterminalParser = GetNonterminal(ToUtf32("Function"));
  218                 functionNonterminalParser->SetPre(PreFunction);
  219             }
  220             public void PreFunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  221             {
  222                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  223                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  224             }
  225             public class Context : System.Text.Parsing.Context
  226             {
  227                 public Context() : context()
  228                 {
  229                 }
  230                 public cmsx.intermediate.Context* context;
  231             }
  232         }
  233 
  234         public class FunctionRule : System.Text.Parsing.RuleParser
  235         {
  236             public FunctionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  237             {
  238                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  239             }
  240             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  241             {
  242                 parsingData->PushContext(Id(), new Context());
  243                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  244                 UniquePtr<Object> context_value = stack.Pop();
  245                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  246             }
  247             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  248             {
  249                 parsingData->PopContext(Id());
  250             }
  251             public override void Link()
  252             {
  253                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  254                 a0ActionParser->SetAction(A0Action);
  255                 NonterminalParser* functionNonterminalParser = GetNonterminal(ToUtf32("function"));
  256                 functionNonterminalParser->SetPre(Prefunction);
  257                 functionNonterminalParser->SetPost(Postfunction);
  258                 NonterminalParser* basicBlockNonterminalParser = GetNonterminal(ToUtf32("BasicBlock"));
  259                 basicBlockNonterminalParser->SetPre(PreBasicBlock);
  260             }
  261             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  262             {
  263                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  264                 context->context->SetCurrentFunction(context->fromfunction);
  265             }
  266             public void Prefunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  267             {
  268                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  269                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  270             }
  271             public void Postfunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  272             {
  273                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  274                 if (matched)
  275                 {
  276                     UniquePtr<Object> fromfunction_value = stack.Pop();
  277                     context->fromfunction = *cast<ValueObject<Function*>*>(fromfunction_value.Get());
  278                 }
  279             }
  280             public void PreBasicBlock(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  281             {
  282                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  283                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  284                 stack.Push(UniquePtr<Object>(new ValueObject<Function*>(context->fromfunction)));
  285             }
  286             public class Context : System.Text.Parsing.Context
  287             {
  288                 public Context() : context(), fromfunction()
  289                 {
  290                 }
  291                 public cmsx.intermediate.Context* context;
  292                 public Function* fromfunction;
  293             }
  294         }
  295 
  296         public class FunctionHeaderRule : System.Text.Parsing.RuleParser
  297         {
  298             public FunctionHeaderRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  299             {
  300                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  301                 SetValueTypeName(ToUtf32("Function*"));
  302             }
  303             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  304             {
  305                 parsingData->PushContext(Id(), new Context());
  306                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  307                 UniquePtr<Object> context_value = stack.Pop();
  308                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  309             }
  310             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  311             {
  312                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  313                 if (matched)
  314                 {
  315                     stack.Push(UniquePtr<Object>(new ValueObject<Function*>(context->value)));
  316                 }
  317                 parsingData->PopContext(Id());
  318             }
  319             public override void Link()
  320             {
  321                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  322                 a0ActionParser->SetAction(A0Action);
  323                 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
  324                 functionTypeNonterminalParser->SetPre(PrefunctionType);
  325                 functionTypeNonterminalParser->SetPost(PostfunctionType);
  326                 NonterminalParser* functionIdNonterminalParser = GetNonterminal(ToUtf32("functionId"));
  327                 functionIdNonterminalParser->SetPost(PostfunctionId);
  328             }
  329             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  330             {
  331                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  332                 context->value = context->context->AddFunction(span.lineNumber, context->fromfunctionType, ToUtf8(context->fromfunctionId));
  333             }
  334             public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  335             {
  336                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  337                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  338             }
  339             public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  340             {
  341                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  342                 if (matched)
  343                 {
  344                     UniquePtr<Object> fromfunctionType_value = stack.Pop();
  345                     context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
  346                 }
  347             }
  348             public void PostfunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  349             {
  350                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  351                 if (matched)
  352                 {
  353                     UniquePtr<Object> fromfunctionId_value = stack.Pop();
  354                     context->fromfunctionId = *cast<ValueObject<ustring>*>(fromfunctionId_value.Get());
  355                 }
  356             }
  357             public class Context : System.Text.Parsing.Context
  358             {
  359                 public Context() : context(), value(), fromfunctionType(), fromfunctionId()
  360                 {
  361                 }
  362                 public cmsx.intermediate.Context* context;
  363                 public Function* value;
  364                 public Type* fromfunctionType;
  365                 public ustring fromfunctionId;
  366             }
  367         }
  368 
  369         public class BasicBlockRule : System.Text.Parsing.RuleParser
  370         {
  371             public BasicBlockRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  372             {
  373                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  374                 AddInheritedAttribute(AttrOrVar(ToUtf32("Function*"), ToUtf32("function")));
  375                 AddLocalVariable(AttrOrVar(ToUtf32("BasicBlock*"), ToUtf32("bb")));
  376             }
  377             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  378             {
  379                 parsingData->PushContext(Id(), new Context());
  380                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  381                 UniquePtr<Object> function_value = stack.Pop();
  382                 context->function = *cast<ValueObject<Function*>*>(function_value.Get());
  383                 UniquePtr<Object> context_value = stack.Pop();
  384                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  385             }
  386             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  387             {
  388                 parsingData->PopContext(Id());
  389             }
  390             public override void Link()
  391             {
  392                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  393                 a0ActionParser->SetAction(A0Action);
  394                 NonterminalParser* idNonterminalParser = GetNonterminal(ToUtf32("id"));
  395                 idNonterminalParser->SetPost(Postid);
  396                 NonterminalParser* instructionLineNonterminalParser = GetNonterminal(ToUtf32("InstructionLine"));
  397                 instructionLineNonterminalParser->SetPre(PreInstructionLine);
  398             }
  399             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  400             {
  401                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  402                 context->bb = context->function->AddBasicBlock(context->fromid);
  403             }
  404             public void Postid(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  405             {
  406                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  407                 if (matched)
  408                 {
  409                     UniquePtr<Object> fromid_value = stack.Pop();
  410                     context->fromid = *cast<ValueObject<uint>*>(fromid_value.Get());
  411                 }
  412             }
  413             public void PreInstructionLine(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  414             {
  415                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  416                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  417                 stack.Push(UniquePtr<Object>(new ValueObject<BasicBlock*>(context->bb)));
  418             }
  419             public class Context : System.Text.Parsing.Context
  420             {
  421                 public Context() : context(), function(), bb(), fromid()
  422                 {
  423                 }
  424                 public cmsx.intermediate.Context* context;
  425                 public Function* function;
  426                 public BasicBlock* bb;
  427                 public uint fromid;
  428             }
  429         }
  430 
  431         public class InstructionLineRule : System.Text.Parsing.RuleParser
  432         {
  433             public InstructionLineRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  434             {
  435                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  436                 AddInheritedAttribute(AttrOrVar(ToUtf32("BasicBlock*"), ToUtf32("bb")));
  437             }
  438             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  439             {
  440                 parsingData->PushContext(Id(), new Context());
  441                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  442                 UniquePtr<Object> bb_value = stack.Pop();
  443                 context->bb = *cast<ValueObject<BasicBlock*>*>(bb_value.Get());
  444                 UniquePtr<Object> context_value = stack.Pop();
  445                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  446             }
  447             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  448             {
  449                 parsingData->PopContext(Id());
  450             }
  451             public override void Link()
  452             {
  453                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  454                 a0ActionParser->SetAction(A0Action);
  455                 NonterminalParser* instructionNonterminalParser = GetNonterminal(ToUtf32("Instruction"));
  456                 instructionNonterminalParser->SetPre(PreInstruction);
  457                 instructionNonterminalParser->SetPost(PostInstruction);
  458             }
  459             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  460             {
  461                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  462                 context->bb->AddInstruction(context->fromInstruction);
  463             }
  464             public void PreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  465             {
  466                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  467                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  468             }
  469             public void PostInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  470             {
  471                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  472                 if (matched)
  473                 {
  474                     UniquePtr<Object> fromInstruction_value = stack.Pop();
  475                     context->fromInstruction = *cast<ValueObject<Instruction*>*>(fromInstruction_value.Get());
  476                 }
  477             }
  478             public class Context : System.Text.Parsing.Context
  479             {
  480                 public Context() : context(), bb(), fromInstruction()
  481                 {
  482                 }
  483                 public cmsx.intermediate.Context* context;
  484                 public BasicBlock* bb;
  485                 public Instruction* fromInstruction;
  486             }
  487         }
  488 
  489         public class InstructionRule : System.Text.Parsing.RuleParser
  490         {
  491             public InstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  492             {
  493                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  494                 SetValueTypeName(ToUtf32("Instruction*"));
  495             }
  496             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  497             {
  498                 parsingData->PushContext(Id(), new Context());
  499                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  500                 UniquePtr<Object> context_value = stack.Pop();
  501                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  502             }
  503             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  504             {
  505                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  506                 if (matched)
  507                 {
  508                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
  509                 }
  510                 parsingData->PopContext(Id());
  511             }
  512             public override void Link()
  513             {
  514                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  515                 a0ActionParser->SetAction(A0Action);
  516                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
  517                 a1ActionParser->SetAction(A1Action);
  518                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
  519                 a2ActionParser->SetAction(A2Action);
  520                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
  521                 a3ActionParser->SetAction(A3Action);
  522                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
  523                 a4ActionParser->SetAction(A4Action);
  524                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
  525                 a5ActionParser->SetAction(A5Action);
  526                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
  527                 a6ActionParser->SetAction(A6Action);
  528                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
  529                 a7ActionParser->SetAction(A7Action);
  530                 NonterminalParser* storeInstructionNonterminalParser = GetNonterminal(ToUtf32("StoreInstruction"));
  531                 storeInstructionNonterminalParser->SetPre(PreStoreInstruction);
  532                 storeInstructionNonterminalParser->SetPost(PostStoreInstruction);
  533                 NonterminalParser* argInstructionNonterminalParser = GetNonterminal(ToUtf32("ArgInstruction"));
  534                 argInstructionNonterminalParser->SetPre(PreArgInstruction);
  535                 argInstructionNonterminalParser->SetPost(PostArgInstruction);
  536                 NonterminalParser* jumpInstructionNonterminalParser = GetNonterminal(ToUtf32("JumpInstruction"));
  537                 jumpInstructionNonterminalParser->SetPre(PreJumpInstruction);
  538                 jumpInstructionNonterminalParser->SetPost(PostJumpInstruction);
  539                 NonterminalParser* branchInstructionNonterminalParser = GetNonterminal(ToUtf32("BranchInstruction"));
  540                 branchInstructionNonterminalParser->SetPre(PreBranchInstruction);
  541                 branchInstructionNonterminalParser->SetPost(PostBranchInstruction);
  542                 NonterminalParser* procedureCallInstructionNonterminalParser = GetNonterminal(ToUtf32("ProcedureCallInstruction"));
  543                 procedureCallInstructionNonterminalParser->SetPre(PreProcedureCallInstruction);
  544                 procedureCallInstructionNonterminalParser->SetPost(PostProcedureCallInstruction);
  545                 NonterminalParser* retInstructionNonterminalParser = GetNonterminal(ToUtf32("RetInstruction"));
  546                 retInstructionNonterminalParser->SetPre(PreRetInstruction);
  547                 retInstructionNonterminalParser->SetPost(PostRetInstruction);
  548                 NonterminalParser* switchInstructionNonterminalParser = GetNonterminal(ToUtf32("SwitchInstruction"));
  549                 switchInstructionNonterminalParser->SetPre(PreSwitchInstruction);
  550                 switchInstructionNonterminalParser->SetPost(PostSwitchInstruction);
  551                 NonterminalParser* valueInstructionNonterminalParser = GetNonterminal(ToUtf32("ValueInstruction"));
  552                 valueInstructionNonterminalParser->SetPre(PreValueInstruction);
  553                 valueInstructionNonterminalParser->SetPost(PostValueInstruction);
  554             }
  555             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  556             {
  557                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  558                 context->value = context->fromStoreInstruction;
  559             }
  560             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  561             {
  562                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  563                 context->value = context->fromArgInstruction;
  564             }
  565             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  566             {
  567                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  568                 context->value = context->fromJumpInstruction;
  569             }
  570             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  571             {
  572                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  573                 context->value = context->fromBranchInstruction;
  574             }
  575             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  576             {
  577                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  578                 context->value = context->fromProcedureCallInstruction;
  579             }
  580             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  581             {
  582                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  583                 context->value = context->fromRetInstruction;
  584             }
  585             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  586             {
  587                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  588                 context->value = context->fromSwitchInstruction;
  589             }
  590             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  591             {
  592                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  593                 context->value = context->fromValueInstruction;
  594             }
  595             public void PreStoreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  596             {
  597                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  598                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  599             }
  600             public void PostStoreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  601             {
  602                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  603                 if (matched)
  604                 {
  605                     UniquePtr<Object> fromStoreInstruction_value = stack.Pop();
  606                     context->fromStoreInstruction = *cast<ValueObject<Instruction*>*>(fromStoreInstruction_value.Get());
  607                 }
  608             }
  609             public void PreArgInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  610             {
  611                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  612                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  613             }
  614             public void PostArgInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  615             {
  616                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  617                 if (matched)
  618                 {
  619                     UniquePtr<Object> fromArgInstruction_value = stack.Pop();
  620                     context->fromArgInstruction = *cast<ValueObject<Instruction*>*>(fromArgInstruction_value.Get());
  621                 }
  622             }
  623             public void PreJumpInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  624             {
  625                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  626                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  627             }
  628             public void PostJumpInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  629             {
  630                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  631                 if (matched)
  632                 {
  633                     UniquePtr<Object> fromJumpInstruction_value = stack.Pop();
  634                     context->fromJumpInstruction = *cast<ValueObject<Instruction*>*>(fromJumpInstruction_value.Get());
  635                 }
  636             }
  637             public void PreBranchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  638             {
  639                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  640                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  641             }
  642             public void PostBranchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  643             {
  644                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  645                 if (matched)
  646                 {
  647                     UniquePtr<Object> fromBranchInstruction_value = stack.Pop();
  648                     context->fromBranchInstruction = *cast<ValueObject<Instruction*>*>(fromBranchInstruction_value.Get());
  649                 }
  650             }
  651             public void PreProcedureCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  652             {
  653                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  654                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  655             }
  656             public void PostProcedureCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  657             {
  658                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  659                 if (matched)
  660                 {
  661                     UniquePtr<Object> fromProcedureCallInstruction_value = stack.Pop();
  662                     context->fromProcedureCallInstruction = *cast<ValueObject<Instruction*>*>(fromProcedureCallInstruction_value.Get());
  663                 }
  664             }
  665             public void PreRetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  666             {
  667                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  668                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  669             }
  670             public void PostRetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  671             {
  672                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  673                 if (matched)
  674                 {
  675                     UniquePtr<Object> fromRetInstruction_value = stack.Pop();
  676                     context->fromRetInstruction = *cast<ValueObject<Instruction*>*>(fromRetInstruction_value.Get());
  677                 }
  678             }
  679             public void PreSwitchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  680             {
  681                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  682                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  683             }
  684             public void PostSwitchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  685             {
  686                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  687                 if (matched)
  688                 {
  689                     UniquePtr<Object> fromSwitchInstruction_value = stack.Pop();
  690                     context->fromSwitchInstruction = *cast<ValueObject<SwitchInstruction*>*>(fromSwitchInstruction_value.Get());
  691                 }
  692             }
  693             public void PreValueInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  694             {
  695                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  696                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  697             }
  698             public void PostValueInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  699             {
  700                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  701                 if (matched)
  702                 {
  703                     UniquePtr<Object> fromValueInstruction_value = stack.Pop();
  704                     context->fromValueInstruction = *cast<ValueObject<Instruction*>*>(fromValueInstruction_value.Get());
  705                 }
  706             }
  707             public class Context : System.Text.Parsing.Context
  708             {
  709                 public Context() : context(), value(), fromStoreInstruction(), fromArgInstruction(), fromJumpInstruction(), fromBranchInstruction(), fromProcedureCallInstruction(), fromRetInstruction(), fromSwitchInstruction(), fromValueInstruction()
  710                 {
  711                 }
  712                 public cmsx.intermediate.Context* context;
  713                 public Instruction* value;
  714                 public Instruction* fromStoreInstruction;
  715                 public Instruction* fromArgInstruction;
  716                 public Instruction* fromJumpInstruction;
  717                 public Instruction* fromBranchInstruction;
  718                 public Instruction* fromProcedureCallInstruction;
  719                 public Instruction* fromRetInstruction;
  720                 public SwitchInstruction* fromSwitchInstruction;
  721                 public Instruction* fromValueInstruction;
  722             }
  723         }
  724 
  725         public class StoreInstructionRule : System.Text.Parsing.RuleParser
  726         {
  727             public StoreInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  728             {
  729                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  730                 SetValueTypeName(ToUtf32("Instruction*"));
  731             }
  732             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  733             {
  734                 parsingData->PushContext(Id(), new Context());
  735                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  736                 UniquePtr<Object> context_value = stack.Pop();
  737                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  738             }
  739             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  740             {
  741                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  742                 if (matched)
  743                 {
  744                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
  745                 }
  746                 parsingData->PopContext(Id());
  747             }
  748             public override void Link()
  749             {
  750                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  751                 a0ActionParser->SetAction(A0Action);
  752                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
  753                 typeNonterminalParser->SetPre(Pretype);
  754                 typeNonterminalParser->SetPost(Posttype);
  755                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
  756                 valNonterminalParser->SetPre(Preval);
  757                 valNonterminalParser->SetPost(Postval);
  758                 NonterminalParser* ptrTypeNonterminalParser = GetNonterminal(ToUtf32("ptrType"));
  759                 ptrTypeNonterminalParser->SetPre(PreptrType);
  760                 ptrTypeNonterminalParser->SetPost(PostptrType);
  761                 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
  762                 ptrNonterminalParser->SetPre(Preptr);
  763                 ptrNonterminalParser->SetPost(Postptr);
  764             }
  765             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  766             {
  767                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  768                 context->value = new StoreInstruction(context->fromval, context->fromptr, span.lineNumber);
  769             }
  770             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  771             {
  772                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  773                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  774             }
  775             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  776             {
  777                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  778                 if (matched)
  779                 {
  780                     UniquePtr<Object> fromtype_value = stack.Pop();
  781                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
  782                 }
  783             }
  784             public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  785             {
  786                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  787                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  788                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
  789             }
  790             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  791             {
  792                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  793                 if (matched)
  794                 {
  795                     UniquePtr<Object> fromval_value = stack.Pop();
  796                     context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
  797                 }
  798             }
  799             public void PreptrType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  800             {
  801                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  802                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  803             }
  804             public void PostptrType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  805             {
  806                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  807                 if (matched)
  808                 {
  809                     UniquePtr<Object> fromptrType_value = stack.Pop();
  810                     context->fromptrType = *cast<ValueObject<Type*>*>(fromptrType_value.Get());
  811                 }
  812             }
  813             public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  814             {
  815                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  816                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  817                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromptrType)));
  818             }
  819             public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  820             {
  821                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  822                 if (matched)
  823                 {
  824                     UniquePtr<Object> fromptr_value = stack.Pop();
  825                     context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
  826                 }
  827             }
  828             public class Context : System.Text.Parsing.Context
  829             {
  830                 public Context() : context(), value(), fromtype(), fromval(), fromptrType(), fromptr()
  831                 {
  832                 }
  833                 public cmsx.intermediate.Context* context;
  834                 public Instruction* value;
  835                 public Type* fromtype;
  836                 public Value* fromval;
  837                 public Type* fromptrType;
  838                 public Value* fromptr;
  839             }
  840         }
  841 
  842         public class ArgInstructionRule : System.Text.Parsing.RuleParser
  843         {
  844             public ArgInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  845             {
  846                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  847                 SetValueTypeName(ToUtf32("Instruction*"));
  848             }
  849             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  850             {
  851                 parsingData->PushContext(Id(), new Context());
  852                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  853                 UniquePtr<Object> context_value = stack.Pop();
  854                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  855             }
  856             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  857             {
  858                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  859                 if (matched)
  860                 {
  861                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
  862                 }
  863                 parsingData->PopContext(Id());
  864             }
  865             public override void Link()
  866             {
  867                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  868                 a0ActionParser->SetAction(A0Action);
  869                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
  870                 typeNonterminalParser->SetPre(Pretype);
  871                 typeNonterminalParser->SetPost(Posttype);
  872                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
  873                 argNonterminalParser->SetPre(Prearg);
  874                 argNonterminalParser->SetPost(Postarg);
  875             }
  876             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  877             {
  878                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  879                 context->value = new ArgInstruction(context->fromarg, span.lineNumber);
  880             }
  881             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  882             {
  883                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  884                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  885             }
  886             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  887             {
  888                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  889                 if (matched)
  890                 {
  891                     UniquePtr<Object> fromtype_value = stack.Pop();
  892                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
  893                 }
  894             }
  895             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  896             {
  897                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  898                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  899                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
  900             }
  901             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  902             {
  903                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  904                 if (matched)
  905                 {
  906                     UniquePtr<Object> fromarg_value = stack.Pop();
  907                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
  908                 }
  909             }
  910             public class Context : System.Text.Parsing.Context
  911             {
  912                 public Context() : context(), value(), fromtype(), fromarg()
  913                 {
  914                 }
  915                 public cmsx.intermediate.Context* context;
  916                 public Instruction* value;
  917                 public Type* fromtype;
  918                 public Value* fromarg;
  919             }
  920         }
  921 
  922         public class JumpInstructionRule : System.Text.Parsing.RuleParser
  923         {
  924             public JumpInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  925             {
  926                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  927                 SetValueTypeName(ToUtf32("Instruction*"));
  928             }
  929             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  930             {
  931                 parsingData->PushContext(Id(), new Context());
  932                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  933                 UniquePtr<Object> context_value = stack.Pop();
  934                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  935             }
  936             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  937             {
  938                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  939                 if (matched)
  940                 {
  941                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
  942                 }
  943                 parsingData->PopContext(Id());
  944             }
  945             public override void Link()
  946             {
  947                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  948                 a0ActionParser->SetAction(A0Action);
  949                 NonterminalParser* targetNonterminalParser = GetNonterminal(ToUtf32("target"));
  950                 targetNonterminalParser->SetPost(Posttarget);
  951             }
  952             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  953             {
  954                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  955                 context->value = new JumpInstruction(context->fromtarget, span.lineNumber);
  956             }
  957             public void Posttarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  958             {
  959                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  960                 if (matched)
  961                 {
  962                     UniquePtr<Object> fromtarget_value = stack.Pop();
  963                     context->fromtarget = *cast<ValueObject<uint>*>(fromtarget_value.Get());
  964                 }
  965             }
  966             public class Context : System.Text.Parsing.Context
  967             {
  968                 public Context() : context(), value(), fromtarget()
  969                 {
  970                 }
  971                 public cmsx.intermediate.Context* context;
  972                 public Instruction* value;
  973                 public uint fromtarget;
  974             }
  975         }
  976 
  977         public class BranchInstructionRule : System.Text.Parsing.RuleParser
  978         {
  979             public BranchInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  980             {
  981                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  982                 SetValueTypeName(ToUtf32("Instruction*"));
  983             }
  984             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  985             {
  986                 parsingData->PushContext(Id(), new Context());
  987                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  988                 UniquePtr<Object> context_value = stack.Pop();
  989                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  990             }
  991             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  992             {
  993                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  994                 if (matched)
  995                 {
  996                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
  997                 }
  998                 parsingData->PopContext(Id());
  999             }
 1000             public override void Link()
 1001             {
 1002                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1003                 a0ActionParser->SetAction(A0Action);
 1004                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 1005                 typeNonterminalParser->SetPre(Pretype);
 1006                 typeNonterminalParser->SetPost(Posttype);
 1007                 NonterminalParser* condNonterminalParser = GetNonterminal(ToUtf32("cond"));
 1008                 condNonterminalParser->SetPre(Precond);
 1009                 condNonterminalParser->SetPost(Postcond);
 1010                 NonterminalParser* trueTargetNonterminalParser = GetNonterminal(ToUtf32("trueTarget"));
 1011                 trueTargetNonterminalParser->SetPost(PosttrueTarget);
 1012                 NonterminalParser* falseTargetNonterminalParser = GetNonterminal(ToUtf32("falseTarget"));
 1013                 falseTargetNonterminalParser->SetPost(PostfalseTarget);
 1014             }
 1015             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1016             {
 1017                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1018                 context->value = new BranchInstruction(context->fromcond, context->fromtrueTarget, context->fromfalseTarget, span.lineNumber);
 1019             }
 1020             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1021             {
 1022                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1023                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1024             }
 1025             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1026             {
 1027                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1028                 if (matched)
 1029                 {
 1030                     UniquePtr<Object> fromtype_value = stack.Pop();
 1031                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 1032                 }
 1033             }
 1034             public void Precond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1035             {
 1036                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1037                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1038                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 1039             }
 1040             public void Postcond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1041             {
 1042                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1043                 if (matched)
 1044                 {
 1045                     UniquePtr<Object> fromcond_value = stack.Pop();
 1046                     context->fromcond = *cast<ValueObject<Value*>*>(fromcond_value.Get());
 1047                 }
 1048             }
 1049             public void PosttrueTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1050             {
 1051                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1052                 if (matched)
 1053                 {
 1054                     UniquePtr<Object> fromtrueTarget_value = stack.Pop();
 1055                     context->fromtrueTarget = *cast<ValueObject<uint>*>(fromtrueTarget_value.Get());
 1056                 }
 1057             }
 1058             public void PostfalseTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1059             {
 1060                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1061                 if (matched)
 1062                 {
 1063                     UniquePtr<Object> fromfalseTarget_value = stack.Pop();
 1064                     context->fromfalseTarget = *cast<ValueObject<uint>*>(fromfalseTarget_value.Get());
 1065                 }
 1066             }
 1067             public class Context : System.Text.Parsing.Context
 1068             {
 1069                 public Context() : context(), value(), fromtype(), fromcond(), fromtrueTarget(), fromfalseTarget()
 1070                 {
 1071                 }
 1072                 public cmsx.intermediate.Context* context;
 1073                 public Instruction* value;
 1074                 public Type* fromtype;
 1075                 public Value* fromcond;
 1076                 public uint fromtrueTarget;
 1077                 public uint fromfalseTarget;
 1078             }
 1079         }
 1080 
 1081         public class ProcedureCallInstructionRule : System.Text.Parsing.RuleParser
 1082         {
 1083             public ProcedureCallInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1084             {
 1085                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1086                 SetValueTypeName(ToUtf32("Instruction*"));
 1087             }
 1088             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1089             {
 1090                 parsingData->PushContext(Id(), new Context());
 1091                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1092                 UniquePtr<Object> context_value = stack.Pop();
 1093                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1094             }
 1095             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1096             {
 1097                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1098                 if (matched)
 1099                 {
 1100                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1101                 }
 1102                 parsingData->PopContext(Id());
 1103             }
 1104             public override void Link()
 1105             {
 1106                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1107                 a0ActionParser->SetAction(A0Action);
 1108                 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
 1109                 functionTypeNonterminalParser->SetPre(PrefunctionType);
 1110                 functionTypeNonterminalParser->SetPost(PostfunctionType);
 1111                 NonterminalParser* calleeNonterminalParser = GetNonterminal(ToUtf32("callee"));
 1112                 calleeNonterminalParser->SetPre(Precallee);
 1113                 calleeNonterminalParser->SetPost(Postcallee);
 1114             }
 1115             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1116             {
 1117                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1118                 context->value = new ProcedureCallInstruction(context->fromcallee, span.lineNumber);
 1119             }
 1120             public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1121             {
 1122                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1123                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1124             }
 1125             public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1126             {
 1127                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1128                 if (matched)
 1129                 {
 1130                     UniquePtr<Object> fromfunctionType_value = stack.Pop();
 1131                     context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
 1132                 }
 1133             }
 1134             public void Precallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1135             {
 1136                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1137                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1138                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromfunctionType)));
 1139             }
 1140             public void Postcallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1141             {
 1142                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1143                 if (matched)
 1144                 {
 1145                     UniquePtr<Object> fromcallee_value = stack.Pop();
 1146                     context->fromcallee = *cast<ValueObject<Value*>*>(fromcallee_value.Get());
 1147                 }
 1148             }
 1149             public class Context : System.Text.Parsing.Context
 1150             {
 1151                 public Context() : context(), value(), fromfunctionType(), fromcallee()
 1152                 {
 1153                 }
 1154                 public cmsx.intermediate.Context* context;
 1155                 public Instruction* value;
 1156                 public Type* fromfunctionType;
 1157                 public Value* fromcallee;
 1158             }
 1159         }
 1160 
 1161         public class RetInstructionRule : System.Text.Parsing.RuleParser
 1162         {
 1163             public RetInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1164             {
 1165                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1166                 SetValueTypeName(ToUtf32("Instruction*"));
 1167             }
 1168             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1169             {
 1170                 parsingData->PushContext(Id(), new Context());
 1171                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1172                 UniquePtr<Object> context_value = stack.Pop();
 1173                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1174             }
 1175             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1176             {
 1177                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1178                 if (matched)
 1179                 {
 1180                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1181                 }
 1182                 parsingData->PopContext(Id());
 1183             }
 1184             public override void Link()
 1185             {
 1186                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1187                 a0ActionParser->SetAction(A0Action);
 1188                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 1189                 a1ActionParser->SetAction(A1Action);
 1190                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 1191                 typeNonterminalParser->SetPre(Pretype);
 1192                 typeNonterminalParser->SetPost(Posttype);
 1193                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 1194                 valNonterminalParser->SetPre(Preval);
 1195                 valNonterminalParser->SetPost(Postval);
 1196             }
 1197             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1198             {
 1199                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1200                 context->value = new RetInstruction(null, span.lineNumber);
 1201             }
 1202             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1203             {
 1204                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1205                 context->value = new RetInstruction(context->fromval, span.lineNumber);
 1206             }
 1207             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1208             {
 1209                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1210                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1211             }
 1212             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1213             {
 1214                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1215                 if (matched)
 1216                 {
 1217                     UniquePtr<Object> fromtype_value = stack.Pop();
 1218                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 1219                 }
 1220             }
 1221             public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1222             {
 1223                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1224                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1225                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 1226             }
 1227             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1228             {
 1229                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1230                 if (matched)
 1231                 {
 1232                     UniquePtr<Object> fromval_value = stack.Pop();
 1233                     context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
 1234                 }
 1235             }
 1236             public class Context : System.Text.Parsing.Context
 1237             {
 1238                 public Context() : context(), value(), fromtype(), fromval()
 1239                 {
 1240                 }
 1241                 public cmsx.intermediate.Context* context;
 1242                 public Instruction* value;
 1243                 public Type* fromtype;
 1244                 public Value* fromval;
 1245             }
 1246         }
 1247 
 1248         public class SwitchInstructionRule : System.Text.Parsing.RuleParser
 1249         {
 1250             public SwitchInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1251             {
 1252                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1253                 SetValueTypeName(ToUtf32("SwitchInstruction*"));
 1254             }
 1255             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1256             {
 1257                 parsingData->PushContext(Id(), new Context());
 1258                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1259                 UniquePtr<Object> context_value = stack.Pop();
 1260                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1261             }
 1262             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1263             {
 1264                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1265                 if (matched)
 1266                 {
 1267                     stack.Push(UniquePtr<Object>(new ValueObject<SwitchInstruction*>(context->value)));
 1268                 }
 1269                 parsingData->PopContext(Id());
 1270             }
 1271             public override void Link()
 1272             {
 1273                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1274                 a0ActionParser->SetAction(A0Action);
 1275                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 1276                 a1ActionParser->SetAction(A1Action);
 1277                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 1278                 typeNonterminalParser->SetPre(Pretype);
 1279                 typeNonterminalParser->SetPost(Posttype);
 1280                 NonterminalParser* condNonterminalParser = GetNonterminal(ToUtf32("cond"));
 1281                 condNonterminalParser->SetPre(Precond);
 1282                 condNonterminalParser->SetPost(Postcond);
 1283                 NonterminalParser* defaultTargetNonterminalParser = GetNonterminal(ToUtf32("defaultTarget"));
 1284                 defaultTargetNonterminalParser->SetPost(PostdefaultTarget);
 1285                 NonterminalParser* caseTypeNonterminalParser = GetNonterminal(ToUtf32("caseType"));
 1286                 caseTypeNonterminalParser->SetPre(PrecaseType);
 1287                 caseTypeNonterminalParser->SetPost(PostcaseType);
 1288                 NonterminalParser* caseValueNonterminalParser = GetNonterminal(ToUtf32("caseValue"));
 1289                 caseValueNonterminalParser->SetPre(PrecaseValue);
 1290                 caseValueNonterminalParser->SetPost(PostcaseValue);
 1291                 NonterminalParser* caseTargetNonterminalParser = GetNonterminal(ToUtf32("caseTarget"));
 1292                 caseTargetNonterminalParser->SetPost(PostcaseTarget);
 1293             }
 1294             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1295             {
 1296                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1297                 context->value = new SwitchInstruction(context->fromcond, context->fromdefaultTarget, span.lineNumber);
 1298             }
 1299             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1300             {
 1301                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1302                 context->value->AddCase(context->fromcaseValue, context->fromcaseTarget);
 1303             }
 1304             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1305             {
 1306                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1307                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1308             }
 1309             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1310             {
 1311                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1312                 if (matched)
 1313                 {
 1314                     UniquePtr<Object> fromtype_value = stack.Pop();
 1315                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 1316                 }
 1317             }
 1318             public void Precond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1319             {
 1320                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1321                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1322                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 1323             }
 1324             public void Postcond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1325             {
 1326                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1327                 if (matched)
 1328                 {
 1329                     UniquePtr<Object> fromcond_value = stack.Pop();
 1330                     context->fromcond = *cast<ValueObject<Value*>*>(fromcond_value.Get());
 1331                 }
 1332             }
 1333             public void PostdefaultTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1334             {
 1335                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1336                 if (matched)
 1337                 {
 1338                     UniquePtr<Object> fromdefaultTarget_value = stack.Pop();
 1339                     context->fromdefaultTarget = *cast<ValueObject<uint>*>(fromdefaultTarget_value.Get());
 1340                 }
 1341             }
 1342             public void PrecaseType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1343             {
 1344                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1345                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1346             }
 1347             public void PostcaseType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1348             {
 1349                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1350                 if (matched)
 1351                 {
 1352                     UniquePtr<Object> fromcaseType_value = stack.Pop();
 1353                     context->fromcaseType = *cast<ValueObject<Type*>*>(fromcaseType_value.Get());
 1354                 }
 1355             }
 1356             public void PrecaseValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1357             {
 1358                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1359                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1360                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromcaseType)));
 1361             }
 1362             public void PostcaseValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1363             {
 1364                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1365                 if (matched)
 1366                 {
 1367                     UniquePtr<Object> fromcaseValue_value = stack.Pop();
 1368                     context->fromcaseValue = *cast<ValueObject<Value*>*>(fromcaseValue_value.Get());
 1369                 }
 1370             }
 1371             public void PostcaseTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1372             {
 1373                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1374                 if (matched)
 1375                 {
 1376                     UniquePtr<Object> fromcaseTarget_value = stack.Pop();
 1377                     context->fromcaseTarget = *cast<ValueObject<uint>*>(fromcaseTarget_value.Get());
 1378                 }
 1379             }
 1380             public class Context : System.Text.Parsing.Context
 1381             {
 1382                 public Context() : context(), value(), fromtype(), fromcond(), fromdefaultTarget(), fromcaseType(), fromcaseValue(), fromcaseTarget()
 1383                 {
 1384                 }
 1385                 public cmsx.intermediate.Context* context;
 1386                 public SwitchInstruction* value;
 1387                 public Type* fromtype;
 1388                 public Value* fromcond;
 1389                 public uint fromdefaultTarget;
 1390                 public Type* fromcaseType;
 1391                 public Value* fromcaseValue;
 1392                 public uint fromcaseTarget;
 1393             }
 1394         }
 1395 
 1396         public class ValueInstructionRule : System.Text.Parsing.RuleParser
 1397         {
 1398             public ValueInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1399             {
 1400                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1401                 SetValueTypeName(ToUtf32("Instruction*"));
 1402             }
 1403             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1404             {
 1405                 parsingData->PushContext(Id(), new Context());
 1406                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1407                 UniquePtr<Object> context_value = stack.Pop();
 1408                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1409             }
 1410             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1411             {
 1412                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1413                 if (matched)
 1414                 {
 1415                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1416                 }
 1417                 parsingData->PopContext(Id());
 1418             }
 1419             public override void Link()
 1420             {
 1421                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1422                 a0ActionParser->SetAction(A0Action);
 1423                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 1424                 typeNonterminalParser->SetPre(Pretype);
 1425                 typeNonterminalParser->SetPost(Posttype);
 1426                 NonterminalParser* resultNonterminalParser = GetNonterminal(ToUtf32("result"));
 1427                 resultNonterminalParser->SetPre(Preresult);
 1428                 resultNonterminalParser->SetPost(Postresult);
 1429                 NonterminalParser* operationNonterminalParser = GetNonterminal(ToUtf32("Operation"));
 1430                 operationNonterminalParser->SetPre(PreOperation);
 1431                 operationNonterminalParser->SetPost(PostOperation);
 1432             }
 1433             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1434             {
 1435                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1436                 context->value = context->fromOperation;
 1437             }
 1438             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1439             {
 1440                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1441                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1442             }
 1443             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1444             {
 1445                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1446                 if (matched)
 1447                 {
 1448                     UniquePtr<Object> fromtype_value = stack.Pop();
 1449                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 1450                 }
 1451             }
 1452             public void Preresult(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1453             {
 1454                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1455                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1456                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 1457             }
 1458             public void Postresult(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1459             {
 1460                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1461                 if (matched)
 1462                 {
 1463                     UniquePtr<Object> fromresult_value = stack.Pop();
 1464                     context->fromresult = *cast<ValueObject<Value*>*>(fromresult_value.Get());
 1465                 }
 1466             }
 1467             public void PreOperation(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1468             {
 1469                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1470                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1471                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->fromresult)));
 1472             }
 1473             public void PostOperation(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1474             {
 1475                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1476                 if (matched)
 1477                 {
 1478                     UniquePtr<Object> fromOperation_value = stack.Pop();
 1479                     context->fromOperation = *cast<ValueObject<Instruction*>*>(fromOperation_value.Get());
 1480                 }
 1481             }
 1482             public class Context : System.Text.Parsing.Context
 1483             {
 1484                 public Context() : context(), value(), fromtype(), fromresult(), fromOperation()
 1485                 {
 1486                 }
 1487                 public cmsx.intermediate.Context* context;
 1488                 public Instruction* value;
 1489                 public Type* fromtype;
 1490                 public Value* fromresult;
 1491                 public Instruction* fromOperation;
 1492             }
 1493         }
 1494 
 1495         public class OperationRule : System.Text.Parsing.RuleParser
 1496         {
 1497             public OperationRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1498             {
 1499                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1500                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 1501                 SetValueTypeName(ToUtf32("Instruction*"));
 1502             }
 1503             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1504             {
 1505                 parsingData->PushContext(Id(), new Context());
 1506                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1507                 UniquePtr<Object> result_value = stack.Pop();
 1508                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 1509                 UniquePtr<Object> context_value = stack.Pop();
 1510                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1511             }
 1512             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1513             {
 1514                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1515                 if (matched)
 1516                 {
 1517                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1518                 }
 1519                 parsingData->PopContext(Id());
 1520             }
 1521             public override void Link()
 1522             {
 1523                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1524                 a0ActionParser->SetAction(A0Action);
 1525                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 1526                 a1ActionParser->SetAction(A1Action);
 1527                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 1528                 a2ActionParser->SetAction(A2Action);
 1529                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 1530                 a3ActionParser->SetAction(A3Action);
 1531                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
 1532                 a4ActionParser->SetAction(A4Action);
 1533                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
 1534                 a5ActionParser->SetAction(A5Action);
 1535                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
 1536                 a6ActionParser->SetAction(A6Action);
 1537                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
 1538                 a7ActionParser->SetAction(A7Action);
 1539                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
 1540                 a8ActionParser->SetAction(A8Action);
 1541                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
 1542                 a9ActionParser->SetAction(A9Action);
 1543                 NonterminalParser* unaryInstructionNonterminalParser = GetNonterminal(ToUtf32("UnaryInstruction"));
 1544                 unaryInstructionNonterminalParser->SetPre(PreUnaryInstruction);
 1545                 unaryInstructionNonterminalParser->SetPost(PostUnaryInstruction);
 1546                 NonterminalParser* binaryInstructionNonterminalParser = GetNonterminal(ToUtf32("BinaryInstruction"));
 1547                 binaryInstructionNonterminalParser->SetPre(PreBinaryInstruction);
 1548                 binaryInstructionNonterminalParser->SetPost(PostBinaryInstruction);
 1549                 NonterminalParser* paramInstructionNonterminalParser = GetNonterminal(ToUtf32("ParamInstruction"));
 1550                 paramInstructionNonterminalParser->SetPre(PreParamInstruction);
 1551                 paramInstructionNonterminalParser->SetPost(PostParamInstruction);
 1552                 NonterminalParser* localInstructionNonterminalParser = GetNonterminal(ToUtf32("LocalInstruction"));
 1553                 localInstructionNonterminalParser->SetPre(PreLocalInstruction);
 1554                 localInstructionNonterminalParser->SetPost(PostLocalInstruction);
 1555                 NonterminalParser* loadInstructionNonterminalParser = GetNonterminal(ToUtf32("LoadInstruction"));
 1556                 loadInstructionNonterminalParser->SetPre(PreLoadInstruction);
 1557                 loadInstructionNonterminalParser->SetPost(PostLoadInstruction);
 1558                 NonterminalParser* elemAddrInstructionNonterminalParser = GetNonterminal(ToUtf32("ElemAddrInstruction"));
 1559                 elemAddrInstructionNonterminalParser->SetPre(PreElemAddrInstruction);
 1560                 elemAddrInstructionNonterminalParser->SetPost(PostElemAddrInstruction);
 1561                 NonterminalParser* ptrOffsetInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrOffsetInstruction"));
 1562                 ptrOffsetInstructionNonterminalParser->SetPre(PrePtrOffsetInstruction);
 1563                 ptrOffsetInstructionNonterminalParser->SetPost(PostPtrOffsetInstruction);
 1564                 NonterminalParser* ptrDiffInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrDiffInstruction"));
 1565                 ptrDiffInstructionNonterminalParser->SetPre(PrePtrDiffInstruction);
 1566                 ptrDiffInstructionNonterminalParser->SetPost(PostPtrDiffInstruction);
 1567                 NonterminalParser* functionCallInstructionNonterminalParser = GetNonterminal(ToUtf32("FunctionCallInstruction"));
 1568                 functionCallInstructionNonterminalParser->SetPre(PreFunctionCallInstruction);
 1569                 functionCallInstructionNonterminalParser->SetPost(PostFunctionCallInstruction);
 1570                 NonterminalParser* trapInstructionNonterminalParser = GetNonterminal(ToUtf32("TrapInstruction"));
 1571                 trapInstructionNonterminalParser->SetPre(PreTrapInstruction);
 1572                 trapInstructionNonterminalParser->SetPost(PostTrapInstruction);
 1573             }
 1574             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1575             {
 1576                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1577                 context->value = context->fromUnaryInstruction;
 1578             }
 1579             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1580             {
 1581                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1582                 context->value = context->fromBinaryInstruction;
 1583             }
 1584             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1585             {
 1586                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1587                 context->value = context->fromParamInstruction;
 1588             }
 1589             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1590             {
 1591                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1592                 context->value = context->fromLocalInstruction;
 1593             }
 1594             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1595             {
 1596                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1597                 context->value = context->fromLoadInstruction;
 1598             }
 1599             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1600             {
 1601                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1602                 context->value = context->fromElemAddrInstruction;
 1603             }
 1604             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1605             {
 1606                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1607                 context->value = context->fromPtrOffsetInstruction;
 1608             }
 1609             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1610             {
 1611                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1612                 context->value = context->fromPtrDiffInstruction;
 1613             }
 1614             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1615             {
 1616                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1617                 context->value = context->fromFunctionCallInstruction;
 1618             }
 1619             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1620             {
 1621                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1622                 context->value = context->fromTrapInstruction;
 1623             }
 1624             public void PreUnaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1625             {
 1626                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1627                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1628                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1629             }
 1630             public void PostUnaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1631             {
 1632                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1633                 if (matched)
 1634                 {
 1635                     UniquePtr<Object> fromUnaryInstruction_value = stack.Pop();
 1636                     context->fromUnaryInstruction = *cast<ValueObject<Instruction*>*>(fromUnaryInstruction_value.Get());
 1637                 }
 1638             }
 1639             public void PreBinaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1640             {
 1641                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1642                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1643                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1644             }
 1645             public void PostBinaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1646             {
 1647                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1648                 if (matched)
 1649                 {
 1650                     UniquePtr<Object> fromBinaryInstruction_value = stack.Pop();
 1651                     context->fromBinaryInstruction = *cast<ValueObject<Instruction*>*>(fromBinaryInstruction_value.Get());
 1652                 }
 1653             }
 1654             public void PreParamInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1655             {
 1656                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1657                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1658                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1659             }
 1660             public void PostParamInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1661             {
 1662                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1663                 if (matched)
 1664                 {
 1665                     UniquePtr<Object> fromParamInstruction_value = stack.Pop();
 1666                     context->fromParamInstruction = *cast<ValueObject<Instruction*>*>(fromParamInstruction_value.Get());
 1667                 }
 1668             }
 1669             public void PreLocalInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1670             {
 1671                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1672                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1673                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1674             }
 1675             public void PostLocalInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1676             {
 1677                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1678                 if (matched)
 1679                 {
 1680                     UniquePtr<Object> fromLocalInstruction_value = stack.Pop();
 1681                     context->fromLocalInstruction = *cast<ValueObject<Instruction*>*>(fromLocalInstruction_value.Get());
 1682                 }
 1683             }
 1684             public void PreLoadInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1685             {
 1686                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1687                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1688                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1689             }
 1690             public void PostLoadInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1691             {
 1692                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1693                 if (matched)
 1694                 {
 1695                     UniquePtr<Object> fromLoadInstruction_value = stack.Pop();
 1696                     context->fromLoadInstruction = *cast<ValueObject<Instruction*>*>(fromLoadInstruction_value.Get());
 1697                 }
 1698             }
 1699             public void PreElemAddrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1700             {
 1701                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1702                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1703                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1704             }
 1705             public void PostElemAddrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1706             {
 1707                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1708                 if (matched)
 1709                 {
 1710                     UniquePtr<Object> fromElemAddrInstruction_value = stack.Pop();
 1711                     context->fromElemAddrInstruction = *cast<ValueObject<Instruction*>*>(fromElemAddrInstruction_value.Get());
 1712                 }
 1713             }
 1714             public void PrePtrOffsetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1715             {
 1716                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1717                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1718                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1719             }
 1720             public void PostPtrOffsetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1721             {
 1722                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1723                 if (matched)
 1724                 {
 1725                     UniquePtr<Object> fromPtrOffsetInstruction_value = stack.Pop();
 1726                     context->fromPtrOffsetInstruction = *cast<ValueObject<Instruction*>*>(fromPtrOffsetInstruction_value.Get());
 1727                 }
 1728             }
 1729             public void PrePtrDiffInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1730             {
 1731                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1732                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1733                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1734             }
 1735             public void PostPtrDiffInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1736             {
 1737                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1738                 if (matched)
 1739                 {
 1740                     UniquePtr<Object> fromPtrDiffInstruction_value = stack.Pop();
 1741                     context->fromPtrDiffInstruction = *cast<ValueObject<Instruction*>*>(fromPtrDiffInstruction_value.Get());
 1742                 }
 1743             }
 1744             public void PreFunctionCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1745             {
 1746                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1747                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1748                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1749             }
 1750             public void PostFunctionCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1751             {
 1752                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1753                 if (matched)
 1754                 {
 1755                     UniquePtr<Object> fromFunctionCallInstruction_value = stack.Pop();
 1756                     context->fromFunctionCallInstruction = *cast<ValueObject<Instruction*>*>(fromFunctionCallInstruction_value.Get());
 1757                 }
 1758             }
 1759             public void PreTrapInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1760             {
 1761                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1762                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1763                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1764             }
 1765             public void PostTrapInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1766             {
 1767                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1768                 if (matched)
 1769                 {
 1770                     UniquePtr<Object> fromTrapInstruction_value = stack.Pop();
 1771                     context->fromTrapInstruction = *cast<ValueObject<Instruction*>*>(fromTrapInstruction_value.Get());
 1772                 }
 1773             }
 1774             public class Context : System.Text.Parsing.Context
 1775             {
 1776                 public Context() : context(), result(), value(), fromUnaryInstruction(), fromBinaryInstruction(), fromParamInstruction(), fromLocalInstruction(), fromLoadInstruction(), fromElemAddrInstruction(), fromPtrOffsetInstruction(), fromPtrDiffInstruction(), fromFunctionCallInstruction(), fromTrapInstruction()
 1777                 {
 1778                 }
 1779                 public cmsx.intermediate.Context* context;
 1780                 public Value* result;
 1781                 public Instruction* value;
 1782                 public Instruction* fromUnaryInstruction;
 1783                 public Instruction* fromBinaryInstruction;
 1784                 public Instruction* fromParamInstruction;
 1785                 public Instruction* fromLocalInstruction;
 1786                 public Instruction* fromLoadInstruction;
 1787                 public Instruction* fromElemAddrInstruction;
 1788                 public Instruction* fromPtrOffsetInstruction;
 1789                 public Instruction* fromPtrDiffInstruction;
 1790                 public Instruction* fromFunctionCallInstruction;
 1791                 public Instruction* fromTrapInstruction;
 1792             }
 1793         }
 1794 
 1795         public class UnaryInstructionRule : System.Text.Parsing.RuleParser
 1796         {
 1797             public UnaryInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1798             {
 1799                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1800                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 1801                 SetValueTypeName(ToUtf32("Instruction*"));
 1802             }
 1803             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1804             {
 1805                 parsingData->PushContext(Id(), new Context());
 1806                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1807                 UniquePtr<Object> result_value = stack.Pop();
 1808                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 1809                 UniquePtr<Object> context_value = stack.Pop();
 1810                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1811             }
 1812             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1813             {
 1814                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1815                 if (matched)
 1816                 {
 1817                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1818                 }
 1819                 parsingData->PopContext(Id());
 1820             }
 1821             public override void Link()
 1822             {
 1823                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1824                 a0ActionParser->SetAction(A0Action);
 1825                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 1826                 a1ActionParser->SetAction(A1Action);
 1827                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 1828                 a2ActionParser->SetAction(A2Action);
 1829                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 1830                 a3ActionParser->SetAction(A3Action);
 1831                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
 1832                 a4ActionParser->SetAction(A4Action);
 1833                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
 1834                 a5ActionParser->SetAction(A5Action);
 1835                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
 1836                 a6ActionParser->SetAction(A6Action);
 1837                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
 1838                 a7ActionParser->SetAction(A7Action);
 1839                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
 1840                 a8ActionParser->SetAction(A8Action);
 1841                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
 1842                 a9ActionParser->SetAction(A9Action);
 1843                 NonterminalParser* notInstructionNonterminalParser = GetNonterminal(ToUtf32("NotInstruction"));
 1844                 notInstructionNonterminalParser->SetPre(PreNotInstruction);
 1845                 notInstructionNonterminalParser->SetPost(PostNotInstruction);
 1846                 NonterminalParser* negInstructionNonterminalParser = GetNonterminal(ToUtf32("NegInstruction"));
 1847                 negInstructionNonterminalParser->SetPre(PreNegInstruction);
 1848                 negInstructionNonterminalParser->SetPost(PostNegInstruction);
 1849                 NonterminalParser* signExtendInstructionNonterminalParser = GetNonterminal(ToUtf32("SignExtendInstruction"));
 1850                 signExtendInstructionNonterminalParser->SetPre(PreSignExtendInstruction);
 1851                 signExtendInstructionNonterminalParser->SetPost(PostSignExtendInstruction);
 1852                 NonterminalParser* zeroExtendInstructionNonterminalParser = GetNonterminal(ToUtf32("ZeroExtendInstruction"));
 1853                 zeroExtendInstructionNonterminalParser->SetPre(PreZeroExtendInstruction);
 1854                 zeroExtendInstructionNonterminalParser->SetPost(PostZeroExtendInstruction);
 1855                 NonterminalParser* truncateInstructionNonterminalParser = GetNonterminal(ToUtf32("TruncateInstruction"));
 1856                 truncateInstructionNonterminalParser->SetPre(PreTruncateInstruction);
 1857                 truncateInstructionNonterminalParser->SetPost(PostTruncateInstruction);
 1858                 NonterminalParser* bitCastInstructionNonterminalParser = GetNonterminal(ToUtf32("BitCastInstruction"));
 1859                 bitCastInstructionNonterminalParser->SetPre(PreBitCastInstruction);
 1860                 bitCastInstructionNonterminalParser->SetPost(PostBitCastInstruction);
 1861                 NonterminalParser* intToFloatInstructionNonterminalParser = GetNonterminal(ToUtf32("IntToFloatInstruction"));
 1862                 intToFloatInstructionNonterminalParser->SetPre(PreIntToFloatInstruction);
 1863                 intToFloatInstructionNonterminalParser->SetPost(PostIntToFloatInstruction);
 1864                 NonterminalParser* floatToIntInstructionNonterminalParser = GetNonterminal(ToUtf32("FloatToIntInstruction"));
 1865                 floatToIntInstructionNonterminalParser->SetPre(PreFloatToIntInstruction);
 1866                 floatToIntInstructionNonterminalParser->SetPost(PostFloatToIntInstruction);
 1867                 NonterminalParser* intToPtrInstructionNonterminalParser = GetNonterminal(ToUtf32("IntToPtrInstruction"));
 1868                 intToPtrInstructionNonterminalParser->SetPre(PreIntToPtrInstruction);
 1869                 intToPtrInstructionNonterminalParser->SetPost(PostIntToPtrInstruction);
 1870                 NonterminalParser* ptrToIntInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrToIntInstruction"));
 1871                 ptrToIntInstructionNonterminalParser->SetPre(PrePtrToIntInstruction);
 1872                 ptrToIntInstructionNonterminalParser->SetPost(PostPtrToIntInstruction);
 1873             }
 1874             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1875             {
 1876                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1877                 context->value = context->fromNotInstruction;
 1878             }
 1879             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1880             {
 1881                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1882                 context->value = context->fromNegInstruction;
 1883             }
 1884             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1885             {
 1886                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1887                 context->value = context->fromSignExtendInstruction;
 1888             }
 1889             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1890             {
 1891                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1892                 context->value = context->fromZeroExtendInstruction;
 1893             }
 1894             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1895             {
 1896                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1897                 context->value = context->fromTruncateInstruction;
 1898             }
 1899             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1900             {
 1901                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1902                 context->value = context->fromBitCastInstruction;
 1903             }
 1904             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1905             {
 1906                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1907                 context->value = context->fromIntToFloatInstruction;
 1908             }
 1909             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1910             {
 1911                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1912                 context->value = context->fromFloatToIntInstruction;
 1913             }
 1914             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1915             {
 1916                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1917                 context->value = context->fromIntToPtrInstruction;
 1918             }
 1919             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1920             {
 1921                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1922                 context->value = context->fromPtrToIntInstruction;
 1923             }
 1924             public void PreNotInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1925             {
 1926                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1927                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1928                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1929             }
 1930             public void PostNotInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1931             {
 1932                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1933                 if (matched)
 1934                 {
 1935                     UniquePtr<Object> fromNotInstruction_value = stack.Pop();
 1936                     context->fromNotInstruction = *cast<ValueObject<Instruction*>*>(fromNotInstruction_value.Get());
 1937                 }
 1938             }
 1939             public void PreNegInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1940             {
 1941                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1942                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1943                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1944             }
 1945             public void PostNegInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1946             {
 1947                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1948                 if (matched)
 1949                 {
 1950                     UniquePtr<Object> fromNegInstruction_value = stack.Pop();
 1951                     context->fromNegInstruction = *cast<ValueObject<Instruction*>*>(fromNegInstruction_value.Get());
 1952                 }
 1953             }
 1954             public void PreSignExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1955             {
 1956                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1957                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1958                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1959             }
 1960             public void PostSignExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1961             {
 1962                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1963                 if (matched)
 1964                 {
 1965                     UniquePtr<Object> fromSignExtendInstruction_value = stack.Pop();
 1966                     context->fromSignExtendInstruction = *cast<ValueObject<Instruction*>*>(fromSignExtendInstruction_value.Get());
 1967                 }
 1968             }
 1969             public void PreZeroExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1970             {
 1971                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1972                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1973                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1974             }
 1975             public void PostZeroExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1976             {
 1977                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1978                 if (matched)
 1979                 {
 1980                     UniquePtr<Object> fromZeroExtendInstruction_value = stack.Pop();
 1981                     context->fromZeroExtendInstruction = *cast<ValueObject<Instruction*>*>(fromZeroExtendInstruction_value.Get());
 1982                 }
 1983             }
 1984             public void PreTruncateInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1985             {
 1986                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1987                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1988                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1989             }
 1990             public void PostTruncateInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1991             {
 1992                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1993                 if (matched)
 1994                 {
 1995                     UniquePtr<Object> fromTruncateInstruction_value = stack.Pop();
 1996                     context->fromTruncateInstruction = *cast<ValueObject<Instruction*>*>(fromTruncateInstruction_value.Get());
 1997                 }
 1998             }
 1999             public void PreBitCastInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2000             {
 2001                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2002                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2003                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2004             }
 2005             public void PostBitCastInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2006             {
 2007                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2008                 if (matched)
 2009                 {
 2010                     UniquePtr<Object> fromBitCastInstruction_value = stack.Pop();
 2011                     context->fromBitCastInstruction = *cast<ValueObject<Instruction*>*>(fromBitCastInstruction_value.Get());
 2012                 }
 2013             }
 2014             public void PreIntToFloatInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2015             {
 2016                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2017                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2018                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2019             }
 2020             public void PostIntToFloatInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2021             {
 2022                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2023                 if (matched)
 2024                 {
 2025                     UniquePtr<Object> fromIntToFloatInstruction_value = stack.Pop();
 2026                     context->fromIntToFloatInstruction = *cast<ValueObject<Instruction*>*>(fromIntToFloatInstruction_value.Get());
 2027                 }
 2028             }
 2029             public void PreFloatToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2030             {
 2031                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2032                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2033                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2034             }
 2035             public void PostFloatToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2036             {
 2037                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2038                 if (matched)
 2039                 {
 2040                     UniquePtr<Object> fromFloatToIntInstruction_value = stack.Pop();
 2041                     context->fromFloatToIntInstruction = *cast<ValueObject<Instruction*>*>(fromFloatToIntInstruction_value.Get());
 2042                 }
 2043             }
 2044             public void PreIntToPtrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2045             {
 2046                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2047                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2048                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2049             }
 2050             public void PostIntToPtrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2051             {
 2052                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2053                 if (matched)
 2054                 {
 2055                     UniquePtr<Object> fromIntToPtrInstruction_value = stack.Pop();
 2056                     context->fromIntToPtrInstruction = *cast<ValueObject<Instruction*>*>(fromIntToPtrInstruction_value.Get());
 2057                 }
 2058             }
 2059             public void PrePtrToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2060             {
 2061                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2062                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2063                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2064             }
 2065             public void PostPtrToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2066             {
 2067                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2068                 if (matched)
 2069                 {
 2070                     UniquePtr<Object> fromPtrToIntInstruction_value = stack.Pop();
 2071                     context->fromPtrToIntInstruction = *cast<ValueObject<Instruction*>*>(fromPtrToIntInstruction_value.Get());
 2072                 }
 2073             }
 2074             public class Context : System.Text.Parsing.Context
 2075             {
 2076                 public Context() : context(), result(), value(), fromNotInstruction(), fromNegInstruction(), fromSignExtendInstruction(), fromZeroExtendInstruction(), fromTruncateInstruction(), fromBitCastInstruction(), fromIntToFloatInstruction(), fromFloatToIntInstruction(), fromIntToPtrInstruction(), fromPtrToIntInstruction()
 2077                 {
 2078                 }
 2079                 public cmsx.intermediate.Context* context;
 2080                 public Value* result;
 2081                 public Instruction* value;
 2082                 public Instruction* fromNotInstruction;
 2083                 public Instruction* fromNegInstruction;
 2084                 public Instruction* fromSignExtendInstruction;
 2085                 public Instruction* fromZeroExtendInstruction;
 2086                 public Instruction* fromTruncateInstruction;
 2087                 public Instruction* fromBitCastInstruction;
 2088                 public Instruction* fromIntToFloatInstruction;
 2089                 public Instruction* fromFloatToIntInstruction;
 2090                 public Instruction* fromIntToPtrInstruction;
 2091                 public Instruction* fromPtrToIntInstruction;
 2092             }
 2093         }
 2094 
 2095         public class NotInstructionRule : System.Text.Parsing.RuleParser
 2096         {
 2097             public NotInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2098             {
 2099                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2100                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2101                 SetValueTypeName(ToUtf32("Instruction*"));
 2102             }
 2103             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2104             {
 2105                 parsingData->PushContext(Id(), new Context());
 2106                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2107                 UniquePtr<Object> result_value = stack.Pop();
 2108                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2109                 UniquePtr<Object> context_value = stack.Pop();
 2110                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2111             }
 2112             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2113             {
 2114                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2115                 if (matched)
 2116                 {
 2117                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2118                 }
 2119                 parsingData->PopContext(Id());
 2120             }
 2121             public override void Link()
 2122             {
 2123                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2124                 a0ActionParser->SetAction(A0Action);
 2125                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2126                 argNonterminalParser->SetPre(Prearg);
 2127                 argNonterminalParser->SetPost(Postarg);
 2128             }
 2129             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2130             {
 2131                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2132                 context->value = new NotInstruction(context->result, context->fromarg, span.lineNumber);
 2133             }
 2134             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2135             {
 2136                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2137                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2138             }
 2139             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2140             {
 2141                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2142                 if (matched)
 2143                 {
 2144                     UniquePtr<Object> fromarg_value = stack.Pop();
 2145                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2146                 }
 2147             }
 2148             public class Context : System.Text.Parsing.Context
 2149             {
 2150                 public Context() : context(), result(), value(), fromarg()
 2151                 {
 2152                 }
 2153                 public cmsx.intermediate.Context* context;
 2154                 public Value* result;
 2155                 public Instruction* value;
 2156                 public Value* fromarg;
 2157             }
 2158         }
 2159 
 2160         public class NegInstructionRule : System.Text.Parsing.RuleParser
 2161         {
 2162             public NegInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2163             {
 2164                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2165                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2166                 SetValueTypeName(ToUtf32("Instruction*"));
 2167             }
 2168             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2169             {
 2170                 parsingData->PushContext(Id(), new Context());
 2171                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2172                 UniquePtr<Object> result_value = stack.Pop();
 2173                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2174                 UniquePtr<Object> context_value = stack.Pop();
 2175                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2176             }
 2177             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2178             {
 2179                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2180                 if (matched)
 2181                 {
 2182                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2183                 }
 2184                 parsingData->PopContext(Id());
 2185             }
 2186             public override void Link()
 2187             {
 2188                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2189                 a0ActionParser->SetAction(A0Action);
 2190                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2191                 argNonterminalParser->SetPre(Prearg);
 2192                 argNonterminalParser->SetPost(Postarg);
 2193             }
 2194             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2195             {
 2196                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2197                 context->value = new NegInstruction(context->result, context->fromarg, span.lineNumber);
 2198             }
 2199             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2200             {
 2201                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2202                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2203             }
 2204             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2205             {
 2206                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2207                 if (matched)
 2208                 {
 2209                     UniquePtr<Object> fromarg_value = stack.Pop();
 2210                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2211                 }
 2212             }
 2213             public class Context : System.Text.Parsing.Context
 2214             {
 2215                 public Context() : context(), result(), value(), fromarg()
 2216                 {
 2217                 }
 2218                 public cmsx.intermediate.Context* context;
 2219                 public Value* result;
 2220                 public Instruction* value;
 2221                 public Value* fromarg;
 2222             }
 2223         }
 2224 
 2225         public class SignExtendInstructionRule : System.Text.Parsing.RuleParser
 2226         {
 2227             public SignExtendInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2228             {
 2229                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2230                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2231                 SetValueTypeName(ToUtf32("Instruction*"));
 2232             }
 2233             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2234             {
 2235                 parsingData->PushContext(Id(), new Context());
 2236                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2237                 UniquePtr<Object> result_value = stack.Pop();
 2238                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2239                 UniquePtr<Object> context_value = stack.Pop();
 2240                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2241             }
 2242             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2243             {
 2244                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2245                 if (matched)
 2246                 {
 2247                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2248                 }
 2249                 parsingData->PopContext(Id());
 2250             }
 2251             public override void Link()
 2252             {
 2253                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2254                 a0ActionParser->SetAction(A0Action);
 2255                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2256                 argNonterminalParser->SetPre(Prearg);
 2257                 argNonterminalParser->SetPost(Postarg);
 2258             }
 2259             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2260             {
 2261                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2262                 context->value = new SignExtendInstruction(context->result, context->fromarg, span.lineNumber);
 2263             }
 2264             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2265             {
 2266                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2267                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2268             }
 2269             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2270             {
 2271                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2272                 if (matched)
 2273                 {
 2274                     UniquePtr<Object> fromarg_value = stack.Pop();
 2275                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2276                 }
 2277             }
 2278             public class Context : System.Text.Parsing.Context
 2279             {
 2280                 public Context() : context(), result(), value(), fromarg()
 2281                 {
 2282                 }
 2283                 public cmsx.intermediate.Context* context;
 2284                 public Value* result;
 2285                 public Instruction* value;
 2286                 public Value* fromarg;
 2287             }
 2288         }
 2289 
 2290         public class ZeroExtendInstructionRule : System.Text.Parsing.RuleParser
 2291         {
 2292             public ZeroExtendInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2293             {
 2294                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2295                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2296                 SetValueTypeName(ToUtf32("Instruction*"));
 2297             }
 2298             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2299             {
 2300                 parsingData->PushContext(Id(), new Context());
 2301                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2302                 UniquePtr<Object> result_value = stack.Pop();
 2303                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2304                 UniquePtr<Object> context_value = stack.Pop();
 2305                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2306             }
 2307             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2308             {
 2309                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2310                 if (matched)
 2311                 {
 2312                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2313                 }
 2314                 parsingData->PopContext(Id());
 2315             }
 2316             public override void Link()
 2317             {
 2318                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2319                 a0ActionParser->SetAction(A0Action);
 2320                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2321                 argNonterminalParser->SetPre(Prearg);
 2322                 argNonterminalParser->SetPost(Postarg);
 2323             }
 2324             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2325             {
 2326                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2327                 context->value = new ZeroExtendInstruction(context->result, context->fromarg, span.lineNumber);
 2328             }
 2329             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2330             {
 2331                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2332                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2333             }
 2334             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2335             {
 2336                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2337                 if (matched)
 2338                 {
 2339                     UniquePtr<Object> fromarg_value = stack.Pop();
 2340                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2341                 }
 2342             }
 2343             public class Context : System.Text.Parsing.Context
 2344             {
 2345                 public Context() : context(), result(), value(), fromarg()
 2346                 {
 2347                 }
 2348                 public cmsx.intermediate.Context* context;
 2349                 public Value* result;
 2350                 public Instruction* value;
 2351                 public Value* fromarg;
 2352             }
 2353         }
 2354 
 2355         public class TruncateInstructionRule : System.Text.Parsing.RuleParser
 2356         {
 2357             public TruncateInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2358             {
 2359                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2360                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2361                 SetValueTypeName(ToUtf32("Instruction*"));
 2362             }
 2363             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2364             {
 2365                 parsingData->PushContext(Id(), new Context());
 2366                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2367                 UniquePtr<Object> result_value = stack.Pop();
 2368                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2369                 UniquePtr<Object> context_value = stack.Pop();
 2370                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2371             }
 2372             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2373             {
 2374                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2375                 if (matched)
 2376                 {
 2377                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2378                 }
 2379                 parsingData->PopContext(Id());
 2380             }
 2381             public override void Link()
 2382             {
 2383                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2384                 a0ActionParser->SetAction(A0Action);
 2385                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2386                 argNonterminalParser->SetPre(Prearg);
 2387                 argNonterminalParser->SetPost(Postarg);
 2388             }
 2389             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2390             {
 2391                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2392                 context->value = new TruncateInstruction(context->result, context->fromarg, span.lineNumber);
 2393             }
 2394             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2395             {
 2396                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2397                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2398             }
 2399             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2400             {
 2401                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2402                 if (matched)
 2403                 {
 2404                     UniquePtr<Object> fromarg_value = stack.Pop();
 2405                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2406                 }
 2407             }
 2408             public class Context : System.Text.Parsing.Context
 2409             {
 2410                 public Context() : context(), result(), value(), fromarg()
 2411                 {
 2412                 }
 2413                 public cmsx.intermediate.Context* context;
 2414                 public Value* result;
 2415                 public Instruction* value;
 2416                 public Value* fromarg;
 2417             }
 2418         }
 2419 
 2420         public class BitCastInstructionRule : System.Text.Parsing.RuleParser
 2421         {
 2422             public BitCastInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2423             {
 2424                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2425                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2426                 SetValueTypeName(ToUtf32("Instruction*"));
 2427             }
 2428             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2429             {
 2430                 parsingData->PushContext(Id(), new Context());
 2431                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2432                 UniquePtr<Object> result_value = stack.Pop();
 2433                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2434                 UniquePtr<Object> context_value = stack.Pop();
 2435                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2436             }
 2437             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2438             {
 2439                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2440                 if (matched)
 2441                 {
 2442                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2443                 }
 2444                 parsingData->PopContext(Id());
 2445             }
 2446             public override void Link()
 2447             {
 2448                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2449                 a0ActionParser->SetAction(A0Action);
 2450                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2451                 argNonterminalParser->SetPre(Prearg);
 2452                 argNonterminalParser->SetPost(Postarg);
 2453             }
 2454             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2455             {
 2456                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2457                 context->value = new BitCastInstruction(context->result, context->fromarg, span.lineNumber);
 2458             }
 2459             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2460             {
 2461                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2462                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2463             }
 2464             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2465             {
 2466                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2467                 if (matched)
 2468                 {
 2469                     UniquePtr<Object> fromarg_value = stack.Pop();
 2470                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2471                 }
 2472             }
 2473             public class Context : System.Text.Parsing.Context
 2474             {
 2475                 public Context() : context(), result(), value(), fromarg()
 2476                 {
 2477                 }
 2478                 public cmsx.intermediate.Context* context;
 2479                 public Value* result;
 2480                 public Instruction* value;
 2481                 public Value* fromarg;
 2482             }
 2483         }
 2484 
 2485         public class IntToFloatInstructionRule : System.Text.Parsing.RuleParser
 2486         {
 2487             public IntToFloatInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2488             {
 2489                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2490                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2491                 SetValueTypeName(ToUtf32("Instruction*"));
 2492             }
 2493             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2494             {
 2495                 parsingData->PushContext(Id(), new Context());
 2496                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2497                 UniquePtr<Object> result_value = stack.Pop();
 2498                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2499                 UniquePtr<Object> context_value = stack.Pop();
 2500                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2501             }
 2502             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2503             {
 2504                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2505                 if (matched)
 2506                 {
 2507                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2508                 }
 2509                 parsingData->PopContext(Id());
 2510             }
 2511             public override void Link()
 2512             {
 2513                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2514                 a0ActionParser->SetAction(A0Action);
 2515                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2516                 argNonterminalParser->SetPre(Prearg);
 2517                 argNonterminalParser->SetPost(Postarg);
 2518             }
 2519             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2520             {
 2521                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2522                 context->value = new IntToFloatInstruction(context->result, context->fromarg, span.lineNumber);
 2523             }
 2524             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2525             {
 2526                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2527                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2528             }
 2529             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2530             {
 2531                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2532                 if (matched)
 2533                 {
 2534                     UniquePtr<Object> fromarg_value = stack.Pop();
 2535                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2536                 }
 2537             }
 2538             public class Context : System.Text.Parsing.Context
 2539             {
 2540                 public Context() : context(), result(), value(), fromarg()
 2541                 {
 2542                 }
 2543                 public cmsx.intermediate.Context* context;
 2544                 public Value* result;
 2545                 public Instruction* value;
 2546                 public Value* fromarg;
 2547             }
 2548         }
 2549 
 2550         public class FloatToIntInstructionRule : System.Text.Parsing.RuleParser
 2551         {
 2552             public FloatToIntInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2553             {
 2554                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2555                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2556                 SetValueTypeName(ToUtf32("Instruction*"));
 2557             }
 2558             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2559             {
 2560                 parsingData->PushContext(Id(), new Context());
 2561                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2562                 UniquePtr<Object> result_value = stack.Pop();
 2563                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2564                 UniquePtr<Object> context_value = stack.Pop();
 2565                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2566             }
 2567             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2568             {
 2569                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2570                 if (matched)
 2571                 {
 2572                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2573                 }
 2574                 parsingData->PopContext(Id());
 2575             }
 2576             public override void Link()
 2577             {
 2578                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2579                 a0ActionParser->SetAction(A0Action);
 2580                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2581                 argNonterminalParser->SetPre(Prearg);
 2582                 argNonterminalParser->SetPost(Postarg);
 2583             }
 2584             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2585             {
 2586                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2587                 context->value = new FloatToIntInstruction(context->result, context->fromarg, span.lineNumber);
 2588             }
 2589             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2590             {
 2591                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2592                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2593             }
 2594             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2595             {
 2596                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2597                 if (matched)
 2598                 {
 2599                     UniquePtr<Object> fromarg_value = stack.Pop();
 2600                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2601                 }
 2602             }
 2603             public class Context : System.Text.Parsing.Context
 2604             {
 2605                 public Context() : context(), result(), value(), fromarg()
 2606                 {
 2607                 }
 2608                 public cmsx.intermediate.Context* context;
 2609                 public Value* result;
 2610                 public Instruction* value;
 2611                 public Value* fromarg;
 2612             }
 2613         }
 2614 
 2615         public class IntToPtrInstructionRule : System.Text.Parsing.RuleParser
 2616         {
 2617             public IntToPtrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2618             {
 2619                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2620                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2621                 SetValueTypeName(ToUtf32("Instruction*"));
 2622             }
 2623             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2624             {
 2625                 parsingData->PushContext(Id(), new Context());
 2626                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2627                 UniquePtr<Object> result_value = stack.Pop();
 2628                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2629                 UniquePtr<Object> context_value = stack.Pop();
 2630                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2631             }
 2632             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2633             {
 2634                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2635                 if (matched)
 2636                 {
 2637                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2638                 }
 2639                 parsingData->PopContext(Id());
 2640             }
 2641             public override void Link()
 2642             {
 2643                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2644                 a0ActionParser->SetAction(A0Action);
 2645                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2646                 argNonterminalParser->SetPre(Prearg);
 2647                 argNonterminalParser->SetPost(Postarg);
 2648             }
 2649             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2650             {
 2651                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2652                 context->value = new IntToPtrInstruction(context->result, context->fromarg, span.lineNumber);
 2653             }
 2654             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2655             {
 2656                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2657                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2658             }
 2659             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2660             {
 2661                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2662                 if (matched)
 2663                 {
 2664                     UniquePtr<Object> fromarg_value = stack.Pop();
 2665                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2666                 }
 2667             }
 2668             public class Context : System.Text.Parsing.Context
 2669             {
 2670                 public Context() : context(), result(), value(), fromarg()
 2671                 {
 2672                 }
 2673                 public cmsx.intermediate.Context* context;
 2674                 public Value* result;
 2675                 public Instruction* value;
 2676                 public Value* fromarg;
 2677             }
 2678         }
 2679 
 2680         public class PtrToIntInstructionRule : System.Text.Parsing.RuleParser
 2681         {
 2682             public PtrToIntInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2683             {
 2684                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2685                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2686                 SetValueTypeName(ToUtf32("Instruction*"));
 2687             }
 2688             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2689             {
 2690                 parsingData->PushContext(Id(), new Context());
 2691                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2692                 UniquePtr<Object> result_value = stack.Pop();
 2693                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2694                 UniquePtr<Object> context_value = stack.Pop();
 2695                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2696             }
 2697             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2698             {
 2699                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2700                 if (matched)
 2701                 {
 2702                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2703                 }
 2704                 parsingData->PopContext(Id());
 2705             }
 2706             public override void Link()
 2707             {
 2708                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2709                 a0ActionParser->SetAction(A0Action);
 2710                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2711                 argNonterminalParser->SetPre(Prearg);
 2712                 argNonterminalParser->SetPost(Postarg);
 2713             }
 2714             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2715             {
 2716                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2717                 context->value = new PtrToIntInstruction(context->result, context->fromarg, span.lineNumber);
 2718             }
 2719             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2720             {
 2721                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2722                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2723             }
 2724             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2725             {
 2726                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2727                 if (matched)
 2728                 {
 2729                     UniquePtr<Object> fromarg_value = stack.Pop();
 2730                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2731                 }
 2732             }
 2733             public class Context : System.Text.Parsing.Context
 2734             {
 2735                 public Context() : context(), result(), value(), fromarg()
 2736                 {
 2737                 }
 2738                 public cmsx.intermediate.Context* context;
 2739                 public Value* result;
 2740                 public Instruction* value;
 2741                 public Value* fromarg;
 2742             }
 2743         }
 2744 
 2745         public class BinaryInstructionRule : System.Text.Parsing.RuleParser
 2746         {
 2747             public BinaryInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2748             {
 2749                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2750                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2751                 SetValueTypeName(ToUtf32("Instruction*"));
 2752             }
 2753             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2754             {
 2755                 parsingData->PushContext(Id(), new Context());
 2756                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2757                 UniquePtr<Object> result_value = stack.Pop();
 2758                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2759                 UniquePtr<Object> context_value = stack.Pop();
 2760                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2761             }
 2762             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2763             {
 2764                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2765                 if (matched)
 2766                 {
 2767                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2768                 }
 2769                 parsingData->PopContext(Id());
 2770             }
 2771             public override void Link()
 2772             {
 2773                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2774                 a0ActionParser->SetAction(A0Action);
 2775                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 2776                 a1ActionParser->SetAction(A1Action);
 2777                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 2778                 a2ActionParser->SetAction(A2Action);
 2779                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 2780                 a3ActionParser->SetAction(A3Action);
 2781                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
 2782                 a4ActionParser->SetAction(A4Action);
 2783                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
 2784                 a5ActionParser->SetAction(A5Action);
 2785                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
 2786                 a6ActionParser->SetAction(A6Action);
 2787                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
 2788                 a7ActionParser->SetAction(A7Action);
 2789                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
 2790                 a8ActionParser->SetAction(A8Action);
 2791                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
 2792                 a9ActionParser->SetAction(A9Action);
 2793                 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
 2794                 a10ActionParser->SetAction(A10Action);
 2795                 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
 2796                 a11ActionParser->SetAction(A11Action);
 2797                 NonterminalParser* addInstructionNonterminalParser = GetNonterminal(ToUtf32("AddInstruction"));
 2798                 addInstructionNonterminalParser->SetPre(PreAddInstruction);
 2799                 addInstructionNonterminalParser->SetPost(PostAddInstruction);
 2800                 NonterminalParser* subInstructionNonterminalParser = GetNonterminal(ToUtf32("SubInstruction"));
 2801                 subInstructionNonterminalParser->SetPre(PreSubInstruction);
 2802                 subInstructionNonterminalParser->SetPost(PostSubInstruction);
 2803                 NonterminalParser* mulInstructionNonterminalParser = GetNonterminal(ToUtf32("MulInstruction"));
 2804                 mulInstructionNonterminalParser->SetPre(PreMulInstruction);
 2805                 mulInstructionNonterminalParser->SetPost(PostMulInstruction);
 2806                 NonterminalParser* divInstructionNonterminalParser = GetNonterminal(ToUtf32("DivInstruction"));
 2807                 divInstructionNonterminalParser->SetPre(PreDivInstruction);
 2808                 divInstructionNonterminalParser->SetPost(PostDivInstruction);
 2809                 NonterminalParser* modInstructionNonterminalParser = GetNonterminal(ToUtf32("ModInstruction"));
 2810                 modInstructionNonterminalParser->SetPre(PreModInstruction);
 2811                 modInstructionNonterminalParser->SetPost(PostModInstruction);
 2812                 NonterminalParser* andInstructionNonterminalParser = GetNonterminal(ToUtf32("AndInstruction"));
 2813                 andInstructionNonterminalParser->SetPre(PreAndInstruction);
 2814                 andInstructionNonterminalParser->SetPost(PostAndInstruction);
 2815                 NonterminalParser* orInstructionNonterminalParser = GetNonterminal(ToUtf32("OrInstruction"));
 2816                 orInstructionNonterminalParser->SetPre(PreOrInstruction);
 2817                 orInstructionNonterminalParser->SetPost(PostOrInstruction);
 2818                 NonterminalParser* xorInstructionNonterminalParser = GetNonterminal(ToUtf32("XorInstruction"));
 2819                 xorInstructionNonterminalParser->SetPre(PreXorInstruction);
 2820                 xorInstructionNonterminalParser->SetPost(PostXorInstruction);
 2821                 NonterminalParser* shlInstructionNonterminalParser = GetNonterminal(ToUtf32("ShlInstruction"));
 2822                 shlInstructionNonterminalParser->SetPre(PreShlInstruction);
 2823                 shlInstructionNonterminalParser->SetPost(PostShlInstruction);
 2824                 NonterminalParser* shrInstructionNonterminalParser = GetNonterminal(ToUtf32("ShrInstruction"));
 2825                 shrInstructionNonterminalParser->SetPre(PreShrInstruction);
 2826                 shrInstructionNonterminalParser->SetPost(PostShrInstruction);
 2827                 NonterminalParser* equalInstructionNonterminalParser = GetNonterminal(ToUtf32("EqualInstruction"));
 2828                 equalInstructionNonterminalParser->SetPre(PreEqualInstruction);
 2829                 equalInstructionNonterminalParser->SetPost(PostEqualInstruction);
 2830                 NonterminalParser* lessInstructionNonterminalParser = GetNonterminal(ToUtf32("LessInstruction"));
 2831                 lessInstructionNonterminalParser->SetPre(PreLessInstruction);
 2832                 lessInstructionNonterminalParser->SetPost(PostLessInstruction);
 2833             }
 2834             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2835             {
 2836                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2837                 context->value = context->fromAddInstruction;
 2838             }
 2839             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2840             {
 2841                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2842                 context->value = context->fromSubInstruction;
 2843             }
 2844             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2845             {
 2846                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2847                 context->value = context->fromMulInstruction;
 2848             }
 2849             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2850             {
 2851                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2852                 context->value = context->fromDivInstruction;
 2853             }
 2854             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2855             {
 2856                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2857                 context->value = context->fromModInstruction;
 2858             }
 2859             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2860             {
 2861                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2862                 context->value = context->fromAndInstruction;
 2863             }
 2864             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2865             {
 2866                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2867                 context->value = context->fromOrInstruction;
 2868             }
 2869             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2870             {
 2871                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2872                 context->value = context->fromXorInstruction;
 2873             }
 2874             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2875             {
 2876                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2877                 context->value = context->fromShlInstruction;
 2878             }
 2879             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2880             {
 2881                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2882                 context->value = context->fromShrInstruction;
 2883             }
 2884             public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2885             {
 2886                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2887                 context->value = context->fromEqualInstruction;
 2888             }
 2889             public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2890             {
 2891                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2892                 context->value = context->fromLessInstruction;
 2893             }
 2894             public void PreAddInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2895             {
 2896                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2897                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2898                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2899             }
 2900             public void PostAddInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2901             {
 2902                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2903                 if (matched)
 2904                 {
 2905                     UniquePtr<Object> fromAddInstruction_value = stack.Pop();
 2906                     context->fromAddInstruction = *cast<ValueObject<Instruction*>*>(fromAddInstruction_value.Get());
 2907                 }
 2908             }
 2909             public void PreSubInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2910             {
 2911                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2912                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2913                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2914             }
 2915             public void PostSubInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2916             {
 2917                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2918                 if (matched)
 2919                 {
 2920                     UniquePtr<Object> fromSubInstruction_value = stack.Pop();
 2921                     context->fromSubInstruction = *cast<ValueObject<Instruction*>*>(fromSubInstruction_value.Get());
 2922                 }
 2923             }
 2924             public void PreMulInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2925             {
 2926                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2927                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2928                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2929             }
 2930             public void PostMulInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2931             {
 2932                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2933                 if (matched)
 2934                 {
 2935                     UniquePtr<Object> fromMulInstruction_value = stack.Pop();
 2936                     context->fromMulInstruction = *cast<ValueObject<Instruction*>*>(fromMulInstruction_value.Get());
 2937                 }
 2938             }
 2939             public void PreDivInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2940             {
 2941                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2942                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2943                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2944             }
 2945             public void PostDivInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2946             {
 2947                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2948                 if (matched)
 2949                 {
 2950                     UniquePtr<Object> fromDivInstruction_value = stack.Pop();
 2951                     context->fromDivInstruction = *cast<ValueObject<Instruction*>*>(fromDivInstruction_value.Get());
 2952                 }
 2953             }
 2954             public void PreModInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2955             {
 2956                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2957                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2958                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2959             }
 2960             public void PostModInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2961             {
 2962                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2963                 if (matched)
 2964                 {
 2965                     UniquePtr<Object> fromModInstruction_value = stack.Pop();
 2966                     context->fromModInstruction = *cast<ValueObject<Instruction*>*>(fromModInstruction_value.Get());
 2967                 }
 2968             }
 2969             public void PreAndInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2970             {
 2971                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2972                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2973                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2974             }
 2975             public void PostAndInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2976             {
 2977                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2978                 if (matched)
 2979                 {
 2980                     UniquePtr<Object> fromAndInstruction_value = stack.Pop();
 2981                     context->fromAndInstruction = *cast<ValueObject<Instruction*>*>(fromAndInstruction_value.Get());
 2982                 }
 2983             }
 2984             public void PreOrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2985             {
 2986                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2987                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2988                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2989             }
 2990             public void PostOrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2991             {
 2992                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2993                 if (matched)
 2994                 {
 2995                     UniquePtr<Object> fromOrInstruction_value = stack.Pop();
 2996                     context->fromOrInstruction = *cast<ValueObject<Instruction*>*>(fromOrInstruction_value.Get());
 2997                 }
 2998             }
 2999             public void PreXorInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3000             {
 3001                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3002                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3003                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3004             }
 3005             public void PostXorInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3006             {
 3007                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3008                 if (matched)
 3009                 {
 3010                     UniquePtr<Object> fromXorInstruction_value = stack.Pop();
 3011                     context->fromXorInstruction = *cast<ValueObject<Instruction*>*>(fromXorInstruction_value.Get());
 3012                 }
 3013             }
 3014             public void PreShlInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3015             {
 3016                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3017                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3018                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3019             }
 3020             public void PostShlInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3021             {
 3022                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3023                 if (matched)
 3024                 {
 3025                     UniquePtr<Object> fromShlInstruction_value = stack.Pop();
 3026                     context->fromShlInstruction = *cast<ValueObject<Instruction*>*>(fromShlInstruction_value.Get());
 3027                 }
 3028             }
 3029             public void PreShrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3030             {
 3031                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3032                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3033                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3034             }
 3035             public void PostShrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3036             {
 3037                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3038                 if (matched)
 3039                 {
 3040                     UniquePtr<Object> fromShrInstruction_value = stack.Pop();
 3041                     context->fromShrInstruction = *cast<ValueObject<Instruction*>*>(fromShrInstruction_value.Get());
 3042                 }
 3043             }
 3044             public void PreEqualInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3045             {
 3046                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3047                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3048                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3049             }
 3050             public void PostEqualInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3051             {
 3052                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3053                 if (matched)
 3054                 {
 3055                     UniquePtr<Object> fromEqualInstruction_value = stack.Pop();
 3056                     context->fromEqualInstruction = *cast<ValueObject<Instruction*>*>(fromEqualInstruction_value.Get());
 3057                 }
 3058             }
 3059             public void PreLessInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3060             {
 3061                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3062                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3063                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3064             }
 3065             public void PostLessInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3066             {
 3067                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3068                 if (matched)
 3069                 {
 3070                     UniquePtr<Object> fromLessInstruction_value = stack.Pop();
 3071                     context->fromLessInstruction = *cast<ValueObject<Instruction*>*>(fromLessInstruction_value.Get());
 3072                 }
 3073             }
 3074             public class Context : System.Text.Parsing.Context
 3075             {
 3076                 public Context() : context(), result(), value(), fromAddInstruction(), fromSubInstruction(), fromMulInstruction(), fromDivInstruction(), fromModInstruction(), fromAndInstruction(), fromOrInstruction(), fromXorInstruction(), fromShlInstruction(), fromShrInstruction(), fromEqualInstruction(), fromLessInstruction()
 3077                 {
 3078                 }
 3079                 public cmsx.intermediate.Context* context;
 3080                 public Value* result;
 3081                 public Instruction* value;
 3082                 public Instruction* fromAddInstruction;
 3083                 public Instruction* fromSubInstruction;
 3084                 public Instruction* fromMulInstruction;
 3085                 public Instruction* fromDivInstruction;
 3086                 public Instruction* fromModInstruction;
 3087                 public Instruction* fromAndInstruction;
 3088                 public Instruction* fromOrInstruction;
 3089                 public Instruction* fromXorInstruction;
 3090                 public Instruction* fromShlInstruction;
 3091                 public Instruction* fromShrInstruction;
 3092                 public Instruction* fromEqualInstruction;
 3093                 public Instruction* fromLessInstruction;
 3094             }
 3095         }
 3096 
 3097         public class AddInstructionRule : System.Text.Parsing.RuleParser
 3098         {
 3099             public AddInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3100             {
 3101                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3102                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3103                 SetValueTypeName(ToUtf32("Instruction*"));
 3104             }
 3105             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3106             {
 3107                 parsingData->PushContext(Id(), new Context());
 3108                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3109                 UniquePtr<Object> result_value = stack.Pop();
 3110                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3111                 UniquePtr<Object> context_value = stack.Pop();
 3112                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3113             }
 3114             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3115             {
 3116                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3117                 if (matched)
 3118                 {
 3119                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3120                 }
 3121                 parsingData->PopContext(Id());
 3122             }
 3123             public override void Link()
 3124             {
 3125                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3126                 a0ActionParser->SetAction(A0Action);
 3127                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3128                 leftNonterminalParser->SetPre(Preleft);
 3129                 leftNonterminalParser->SetPost(Postleft);
 3130                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3131                 rightNonterminalParser->SetPre(Preright);
 3132                 rightNonterminalParser->SetPost(Postright);
 3133             }
 3134             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3135             {
 3136                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3137                 context->value = new AddInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3138             }
 3139             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3140             {
 3141                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3142                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3143             }
 3144             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3145             {
 3146                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3147                 if (matched)
 3148                 {
 3149                     UniquePtr<Object> fromleft_value = stack.Pop();
 3150                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3151                 }
 3152             }
 3153             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3154             {
 3155                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3156                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3157             }
 3158             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3159             {
 3160                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3161                 if (matched)
 3162                 {
 3163                     UniquePtr<Object> fromright_value = stack.Pop();
 3164                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3165                 }
 3166             }
 3167             public class Context : System.Text.Parsing.Context
 3168             {
 3169                 public Context() : context(), result(), value(), fromleft(), fromright()
 3170                 {
 3171                 }
 3172                 public cmsx.intermediate.Context* context;
 3173                 public Value* result;
 3174                 public Instruction* value;
 3175                 public Value* fromleft;
 3176                 public Value* fromright;
 3177             }
 3178         }
 3179 
 3180         public class SubInstructionRule : System.Text.Parsing.RuleParser
 3181         {
 3182             public SubInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3183             {
 3184                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3185                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3186                 SetValueTypeName(ToUtf32("Instruction*"));
 3187             }
 3188             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3189             {
 3190                 parsingData->PushContext(Id(), new Context());
 3191                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3192                 UniquePtr<Object> result_value = stack.Pop();
 3193                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3194                 UniquePtr<Object> context_value = stack.Pop();
 3195                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3196             }
 3197             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3198             {
 3199                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3200                 if (matched)
 3201                 {
 3202                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3203                 }
 3204                 parsingData->PopContext(Id());
 3205             }
 3206             public override void Link()
 3207             {
 3208                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3209                 a0ActionParser->SetAction(A0Action);
 3210                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3211                 leftNonterminalParser->SetPre(Preleft);
 3212                 leftNonterminalParser->SetPost(Postleft);
 3213                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3214                 rightNonterminalParser->SetPre(Preright);
 3215                 rightNonterminalParser->SetPost(Postright);
 3216             }
 3217             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3218             {
 3219                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3220                 context->value = new SubInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3221             }
 3222             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3223             {
 3224                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3225                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3226             }
 3227             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3228             {
 3229                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3230                 if (matched)
 3231                 {
 3232                     UniquePtr<Object> fromleft_value = stack.Pop();
 3233                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3234                 }
 3235             }
 3236             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3237             {
 3238                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3239                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3240             }
 3241             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3242             {
 3243                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3244                 if (matched)
 3245                 {
 3246                     UniquePtr<Object> fromright_value = stack.Pop();
 3247                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3248                 }
 3249             }
 3250             public class Context : System.Text.Parsing.Context
 3251             {
 3252                 public Context() : context(), result(), value(), fromleft(), fromright()
 3253                 {
 3254                 }
 3255                 public cmsx.intermediate.Context* context;
 3256                 public Value* result;
 3257                 public Instruction* value;
 3258                 public Value* fromleft;
 3259                 public Value* fromright;
 3260             }
 3261         }
 3262 
 3263         public class MulInstructionRule : System.Text.Parsing.RuleParser
 3264         {
 3265             public MulInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3266             {
 3267                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3268                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3269                 SetValueTypeName(ToUtf32("Instruction*"));
 3270             }
 3271             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3272             {
 3273                 parsingData->PushContext(Id(), new Context());
 3274                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3275                 UniquePtr<Object> result_value = stack.Pop();
 3276                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3277                 UniquePtr<Object> context_value = stack.Pop();
 3278                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3279             }
 3280             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3281             {
 3282                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3283                 if (matched)
 3284                 {
 3285                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3286                 }
 3287                 parsingData->PopContext(Id());
 3288             }
 3289             public override void Link()
 3290             {
 3291                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3292                 a0ActionParser->SetAction(A0Action);
 3293                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3294                 leftNonterminalParser->SetPre(Preleft);
 3295                 leftNonterminalParser->SetPost(Postleft);
 3296                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3297                 rightNonterminalParser->SetPre(Preright);
 3298                 rightNonterminalParser->SetPost(Postright);
 3299             }
 3300             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3301             {
 3302                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3303                 context->value = new MulInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3304             }
 3305             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3306             {
 3307                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3308                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3309             }
 3310             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3311             {
 3312                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3313                 if (matched)
 3314                 {
 3315                     UniquePtr<Object> fromleft_value = stack.Pop();
 3316                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3317                 }
 3318             }
 3319             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3320             {
 3321                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3322                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3323             }
 3324             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3325             {
 3326                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3327                 if (matched)
 3328                 {
 3329                     UniquePtr<Object> fromright_value = stack.Pop();
 3330                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3331                 }
 3332             }
 3333             public class Context : System.Text.Parsing.Context
 3334             {
 3335                 public Context() : context(), result(), value(), fromleft(), fromright()
 3336                 {
 3337                 }
 3338                 public cmsx.intermediate.Context* context;
 3339                 public Value* result;
 3340                 public Instruction* value;
 3341                 public Value* fromleft;
 3342                 public Value* fromright;
 3343             }
 3344         }
 3345 
 3346         public class DivInstructionRule : System.Text.Parsing.RuleParser
 3347         {
 3348             public DivInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3349             {
 3350                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3351                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3352                 SetValueTypeName(ToUtf32("Instruction*"));
 3353             }
 3354             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3355             {
 3356                 parsingData->PushContext(Id(), new Context());
 3357                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3358                 UniquePtr<Object> result_value = stack.Pop();
 3359                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3360                 UniquePtr<Object> context_value = stack.Pop();
 3361                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3362             }
 3363             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3364             {
 3365                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3366                 if (matched)
 3367                 {
 3368                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3369                 }
 3370                 parsingData->PopContext(Id());
 3371             }
 3372             public override void Link()
 3373             {
 3374                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3375                 a0ActionParser->SetAction(A0Action);
 3376                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3377                 leftNonterminalParser->SetPre(Preleft);
 3378                 leftNonterminalParser->SetPost(Postleft);
 3379                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3380                 rightNonterminalParser->SetPre(Preright);
 3381                 rightNonterminalParser->SetPost(Postright);
 3382             }
 3383             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3384             {
 3385                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3386                 context->value = new DivInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3387             }
 3388             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3389             {
 3390                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3391                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3392             }
 3393             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3394             {
 3395                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3396                 if (matched)
 3397                 {
 3398                     UniquePtr<Object> fromleft_value = stack.Pop();
 3399                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3400                 }
 3401             }
 3402             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3403             {
 3404                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3405                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3406             }
 3407             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3408             {
 3409                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3410                 if (matched)
 3411                 {
 3412                     UniquePtr<Object> fromright_value = stack.Pop();
 3413                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3414                 }
 3415             }
 3416             public class Context : System.Text.Parsing.Context
 3417             {
 3418                 public Context() : context(), result(), value(), fromleft(), fromright()
 3419                 {
 3420                 }
 3421                 public cmsx.intermediate.Context* context;
 3422                 public Value* result;
 3423                 public Instruction* value;
 3424                 public Value* fromleft;
 3425                 public Value* fromright;
 3426             }
 3427         }
 3428 
 3429         public class ModInstructionRule : System.Text.Parsing.RuleParser
 3430         {
 3431             public ModInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3432             {
 3433                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3434                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3435                 SetValueTypeName(ToUtf32("Instruction*"));
 3436             }
 3437             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3438             {
 3439                 parsingData->PushContext(Id(), new Context());
 3440                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3441                 UniquePtr<Object> result_value = stack.Pop();
 3442                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3443                 UniquePtr<Object> context_value = stack.Pop();
 3444                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3445             }
 3446             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3447             {
 3448                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3449                 if (matched)
 3450                 {
 3451                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3452                 }
 3453                 parsingData->PopContext(Id());
 3454             }
 3455             public override void Link()
 3456             {
 3457                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3458                 a0ActionParser->SetAction(A0Action);
 3459                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3460                 leftNonterminalParser->SetPre(Preleft);
 3461                 leftNonterminalParser->SetPost(Postleft);
 3462                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3463                 rightNonterminalParser->SetPre(Preright);
 3464                 rightNonterminalParser->SetPost(Postright);
 3465             }
 3466             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3467             {
 3468                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3469                 context->value = new ModInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3470             }
 3471             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3472             {
 3473                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3474                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3475             }
 3476             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3477             {
 3478                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3479                 if (matched)
 3480                 {
 3481                     UniquePtr<Object> fromleft_value = stack.Pop();
 3482                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3483                 }
 3484             }
 3485             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3486             {
 3487                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3488                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3489             }
 3490             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3491             {
 3492                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3493                 if (matched)
 3494                 {
 3495                     UniquePtr<Object> fromright_value = stack.Pop();
 3496                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3497                 }
 3498             }
 3499             public class Context : System.Text.Parsing.Context
 3500             {
 3501                 public Context() : context(), result(), value(), fromleft(), fromright()
 3502                 {
 3503                 }
 3504                 public cmsx.intermediate.Context* context;
 3505                 public Value* result;
 3506                 public Instruction* value;
 3507                 public Value* fromleft;
 3508                 public Value* fromright;
 3509             }
 3510         }
 3511 
 3512         public class AndInstructionRule : System.Text.Parsing.RuleParser
 3513         {
 3514             public AndInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3515             {
 3516                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3517                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3518                 SetValueTypeName(ToUtf32("Instruction*"));
 3519             }
 3520             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3521             {
 3522                 parsingData->PushContext(Id(), new Context());
 3523                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3524                 UniquePtr<Object> result_value = stack.Pop();
 3525                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3526                 UniquePtr<Object> context_value = stack.Pop();
 3527                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3528             }
 3529             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3530             {
 3531                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3532                 if (matched)
 3533                 {
 3534                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3535                 }
 3536                 parsingData->PopContext(Id());
 3537             }
 3538             public override void Link()
 3539             {
 3540                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3541                 a0ActionParser->SetAction(A0Action);
 3542                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3543                 leftNonterminalParser->SetPre(Preleft);
 3544                 leftNonterminalParser->SetPost(Postleft);
 3545                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3546                 rightNonterminalParser->SetPre(Preright);
 3547                 rightNonterminalParser->SetPost(Postright);
 3548             }
 3549             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3550             {
 3551                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3552                 context->value = new AndInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3553             }
 3554             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3555             {
 3556                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3557                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3558             }
 3559             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3560             {
 3561                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3562                 if (matched)
 3563                 {
 3564                     UniquePtr<Object> fromleft_value = stack.Pop();
 3565                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3566                 }
 3567             }
 3568             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3569             {
 3570                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3571                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3572             }
 3573             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3574             {
 3575                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3576                 if (matched)
 3577                 {
 3578                     UniquePtr<Object> fromright_value = stack.Pop();
 3579                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3580                 }
 3581             }
 3582             public class Context : System.Text.Parsing.Context
 3583             {
 3584                 public Context() : context(), result(), value(), fromleft(), fromright()
 3585                 {
 3586                 }
 3587                 public cmsx.intermediate.Context* context;
 3588                 public Value* result;
 3589                 public Instruction* value;
 3590                 public Value* fromleft;
 3591                 public Value* fromright;
 3592             }
 3593         }
 3594 
 3595         public class OrInstructionRule : System.Text.Parsing.RuleParser
 3596         {
 3597             public OrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3598             {
 3599                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3600                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3601                 SetValueTypeName(ToUtf32("Instruction*"));
 3602             }
 3603             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3604             {
 3605                 parsingData->PushContext(Id(), new Context());
 3606                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3607                 UniquePtr<Object> result_value = stack.Pop();
 3608                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3609                 UniquePtr<Object> context_value = stack.Pop();
 3610                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3611             }
 3612             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3613             {
 3614                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3615                 if (matched)
 3616                 {
 3617                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3618                 }
 3619                 parsingData->PopContext(Id());
 3620             }
 3621             public override void Link()
 3622             {
 3623                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3624                 a0ActionParser->SetAction(A0Action);
 3625                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3626                 leftNonterminalParser->SetPre(Preleft);
 3627                 leftNonterminalParser->SetPost(Postleft);
 3628                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3629                 rightNonterminalParser->SetPre(Preright);
 3630                 rightNonterminalParser->SetPost(Postright);
 3631             }
 3632             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3633             {
 3634                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3635                 context->value = new OrInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3636             }
 3637             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3638             {
 3639                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3640                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3641             }
 3642             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3643             {
 3644                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3645                 if (matched)
 3646                 {
 3647                     UniquePtr<Object> fromleft_value = stack.Pop();
 3648                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3649                 }
 3650             }
 3651             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3652             {
 3653                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3654                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3655             }
 3656             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3657             {
 3658                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3659                 if (matched)
 3660                 {
 3661                     UniquePtr<Object> fromright_value = stack.Pop();
 3662                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3663                 }
 3664             }
 3665             public class Context : System.Text.Parsing.Context
 3666             {
 3667                 public Context() : context(), result(), value(), fromleft(), fromright()
 3668                 {
 3669                 }
 3670                 public cmsx.intermediate.Context* context;
 3671                 public Value* result;
 3672                 public Instruction* value;
 3673                 public Value* fromleft;
 3674                 public Value* fromright;
 3675             }
 3676         }
 3677 
 3678         public class XorInstructionRule : System.Text.Parsing.RuleParser
 3679         {
 3680             public XorInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3681             {
 3682                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3683                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3684                 SetValueTypeName(ToUtf32("Instruction*"));
 3685             }
 3686             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3687             {
 3688                 parsingData->PushContext(Id(), new Context());
 3689                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3690                 UniquePtr<Object> result_value = stack.Pop();
 3691                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3692                 UniquePtr<Object> context_value = stack.Pop();
 3693                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3694             }
 3695             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3696             {
 3697                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3698                 if (matched)
 3699                 {
 3700                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3701                 }
 3702                 parsingData->PopContext(Id());
 3703             }
 3704             public override void Link()
 3705             {
 3706                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3707                 a0ActionParser->SetAction(A0Action);
 3708                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3709                 leftNonterminalParser->SetPre(Preleft);
 3710                 leftNonterminalParser->SetPost(Postleft);
 3711                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3712                 rightNonterminalParser->SetPre(Preright);
 3713                 rightNonterminalParser->SetPost(Postright);
 3714             }
 3715             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3716             {
 3717                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3718                 context->value = new XorInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3719             }
 3720             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3721             {
 3722                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3723                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3724             }
 3725             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3726             {
 3727                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3728                 if (matched)
 3729                 {
 3730                     UniquePtr<Object> fromleft_value = stack.Pop();
 3731                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3732                 }
 3733             }
 3734             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3735             {
 3736                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3737                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3738             }
 3739             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3740             {
 3741                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3742                 if (matched)
 3743                 {
 3744                     UniquePtr<Object> fromright_value = stack.Pop();
 3745                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3746                 }
 3747             }
 3748             public class Context : System.Text.Parsing.Context
 3749             {
 3750                 public Context() : context(), result(), value(), fromleft(), fromright()
 3751                 {
 3752                 }
 3753                 public cmsx.intermediate.Context* context;
 3754                 public Value* result;
 3755                 public Instruction* value;
 3756                 public Value* fromleft;
 3757                 public Value* fromright;
 3758             }
 3759         }
 3760 
 3761         public class ShlInstructionRule : System.Text.Parsing.RuleParser
 3762         {
 3763             public ShlInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3764             {
 3765                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3766                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3767                 SetValueTypeName(ToUtf32("Instruction*"));
 3768             }
 3769             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3770             {
 3771                 parsingData->PushContext(Id(), new Context());
 3772                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3773                 UniquePtr<Object> result_value = stack.Pop();
 3774                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3775                 UniquePtr<Object> context_value = stack.Pop();
 3776                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3777             }
 3778             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3779             {
 3780                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3781                 if (matched)
 3782                 {
 3783                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3784                 }
 3785                 parsingData->PopContext(Id());
 3786             }
 3787             public override void Link()
 3788             {
 3789                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3790                 a0ActionParser->SetAction(A0Action);
 3791                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3792                 leftNonterminalParser->SetPre(Preleft);
 3793                 leftNonterminalParser->SetPost(Postleft);
 3794                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3795                 rightNonterminalParser->SetPre(Preright);
 3796                 rightNonterminalParser->SetPost(Postright);
 3797             }
 3798             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3799             {
 3800                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3801                 context->value = new ShlInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3802             }
 3803             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3804             {
 3805                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3806                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3807             }
 3808             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3809             {
 3810                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3811                 if (matched)
 3812                 {
 3813                     UniquePtr<Object> fromleft_value = stack.Pop();
 3814                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3815                 }
 3816             }
 3817             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3818             {
 3819                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3820                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3821             }
 3822             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3823             {
 3824                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3825                 if (matched)
 3826                 {
 3827                     UniquePtr<Object> fromright_value = stack.Pop();
 3828                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3829                 }
 3830             }
 3831             public class Context : System.Text.Parsing.Context
 3832             {
 3833                 public Context() : context(), result(), value(), fromleft(), fromright()
 3834                 {
 3835                 }
 3836                 public cmsx.intermediate.Context* context;
 3837                 public Value* result;
 3838                 public Instruction* value;
 3839                 public Value* fromleft;
 3840                 public Value* fromright;
 3841             }
 3842         }
 3843 
 3844         public class ShrInstructionRule : System.Text.Parsing.RuleParser
 3845         {
 3846             public ShrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3847             {
 3848                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3849                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3850                 SetValueTypeName(ToUtf32("Instruction*"));
 3851             }
 3852             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3853             {
 3854                 parsingData->PushContext(Id(), new Context());
 3855                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3856                 UniquePtr<Object> result_value = stack.Pop();
 3857                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3858                 UniquePtr<Object> context_value = stack.Pop();
 3859                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3860             }
 3861             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3862             {
 3863                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3864                 if (matched)
 3865                 {
 3866                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3867                 }
 3868                 parsingData->PopContext(Id());
 3869             }
 3870             public override void Link()
 3871             {
 3872                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3873                 a0ActionParser->SetAction(A0Action);
 3874                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3875                 leftNonterminalParser->SetPre(Preleft);
 3876                 leftNonterminalParser->SetPost(Postleft);
 3877                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3878                 rightNonterminalParser->SetPre(Preright);
 3879                 rightNonterminalParser->SetPost(Postright);
 3880             }
 3881             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3882             {
 3883                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3884                 context->value = new ShrInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3885             }
 3886             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3887             {
 3888                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3889                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3890             }
 3891             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3892             {
 3893                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3894                 if (matched)
 3895                 {
 3896                     UniquePtr<Object> fromleft_value = stack.Pop();
 3897                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3898                 }
 3899             }
 3900             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3901             {
 3902                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3903                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3904             }
 3905             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3906             {
 3907                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3908                 if (matched)
 3909                 {
 3910                     UniquePtr<Object> fromright_value = stack.Pop();
 3911                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3912                 }
 3913             }
 3914             public class Context : System.Text.Parsing.Context
 3915             {
 3916                 public Context() : context(), result(), value(), fromleft(), fromright()
 3917                 {
 3918                 }
 3919                 public cmsx.intermediate.Context* context;
 3920                 public Value* result;
 3921                 public Instruction* value;
 3922                 public Value* fromleft;
 3923                 public Value* fromright;
 3924             }
 3925         }
 3926 
 3927         public class EqualInstructionRule : System.Text.Parsing.RuleParser
 3928         {
 3929             public EqualInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3930             {
 3931                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3932                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3933                 SetValueTypeName(ToUtf32("Instruction*"));
 3934             }
 3935             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3936             {
 3937                 parsingData->PushContext(Id(), new Context());
 3938                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3939                 UniquePtr<Object> result_value = stack.Pop();
 3940                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3941                 UniquePtr<Object> context_value = stack.Pop();
 3942                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3943             }
 3944             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3945             {
 3946                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3947                 if (matched)
 3948                 {
 3949                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3950                 }
 3951                 parsingData->PopContext(Id());
 3952             }
 3953             public override void Link()
 3954             {
 3955                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3956                 a0ActionParser->SetAction(A0Action);
 3957                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3958                 leftNonterminalParser->SetPre(Preleft);
 3959                 leftNonterminalParser->SetPost(Postleft);
 3960                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3961                 rightNonterminalParser->SetPre(Preright);
 3962                 rightNonterminalParser->SetPost(Postright);
 3963             }
 3964             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3965             {
 3966                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3967                 context->value = new EqualInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3968             }
 3969             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3970             {
 3971                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3972                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3973             }
 3974             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3975             {
 3976                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3977                 if (matched)
 3978                 {
 3979                     UniquePtr<Object> fromleft_value = stack.Pop();
 3980                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3981                 }
 3982             }
 3983             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3984             {
 3985                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3986                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3987             }
 3988             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3989             {
 3990                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3991                 if (matched)
 3992                 {
 3993                     UniquePtr<Object> fromright_value = stack.Pop();
 3994                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3995                 }
 3996             }
 3997             public class Context : System.Text.Parsing.Context
 3998             {
 3999                 public Context() : context(), result(), value(), fromleft(), fromright()
 4000                 {
 4001                 }
 4002                 public cmsx.intermediate.Context* context;
 4003                 public Value* result;
 4004                 public Instruction* value;
 4005                 public Value* fromleft;
 4006                 public Value* fromright;
 4007             }
 4008         }
 4009 
 4010         public class LessInstructionRule : System.Text.Parsing.RuleParser
 4011         {
 4012             public LessInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4013             {
 4014                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4015                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4016                 SetValueTypeName(ToUtf32("Instruction*"));
 4017             }
 4018             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4019             {
 4020                 parsingData->PushContext(Id(), new Context());
 4021                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4022                 UniquePtr<Object> result_value = stack.Pop();
 4023                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4024                 UniquePtr<Object> context_value = stack.Pop();
 4025                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4026             }
 4027             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4028             {
 4029                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4030                 if (matched)
 4031                 {
 4032                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4033                 }
 4034                 parsingData->PopContext(Id());
 4035             }
 4036             public override void Link()
 4037             {
 4038                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4039                 a0ActionParser->SetAction(A0Action);
 4040                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 4041                 leftNonterminalParser->SetPre(Preleft);
 4042                 leftNonterminalParser->SetPost(Postleft);
 4043                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 4044                 rightNonterminalParser->SetPre(Preright);
 4045                 rightNonterminalParser->SetPost(Postright);
 4046             }
 4047             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4048             {
 4049                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4050                 context->value = new LessInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 4051             }
 4052             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4053             {
 4054                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4055                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4056             }
 4057             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4058             {
 4059                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4060                 if (matched)
 4061                 {
 4062                     UniquePtr<Object> fromleft_value = stack.Pop();
 4063                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 4064                 }
 4065             }
 4066             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4067             {
 4068                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4069                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4070             }
 4071             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4072             {
 4073                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4074                 if (matched)
 4075                 {
 4076                     UniquePtr<Object> fromright_value = stack.Pop();
 4077                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 4078                 }
 4079             }
 4080             public class Context : System.Text.Parsing.Context
 4081             {
 4082                 public Context() : context(), result(), value(), fromleft(), fromright()
 4083                 {
 4084                 }
 4085                 public cmsx.intermediate.Context* context;
 4086                 public Value* result;
 4087                 public Instruction* value;
 4088                 public Value* fromleft;
 4089                 public Value* fromright;
 4090             }
 4091         }
 4092 
 4093         public class ParamInstructionRule : System.Text.Parsing.RuleParser
 4094         {
 4095             public ParamInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4096             {
 4097                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4098                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4099                 SetValueTypeName(ToUtf32("Instruction*"));
 4100             }
 4101             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4102             {
 4103                 parsingData->PushContext(Id(), new Context());
 4104                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4105                 UniquePtr<Object> result_value = stack.Pop();
 4106                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4107                 UniquePtr<Object> context_value = stack.Pop();
 4108                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4109             }
 4110             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4111             {
 4112                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4113                 if (matched)
 4114                 {
 4115                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4116                 }
 4117                 parsingData->PopContext(Id());
 4118             }
 4119             public override void Link()
 4120             {
 4121                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4122                 a0ActionParser->SetAction(A0Action);
 4123             }
 4124             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4125             {
 4126                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4127                 context->value = new ParamInstruction(context->result, span.lineNumber);
 4128             }
 4129             public class Context : System.Text.Parsing.Context
 4130             {
 4131                 public Context() : context(), result(), value()
 4132                 {
 4133                 }
 4134                 public cmsx.intermediate.Context* context;
 4135                 public Value* result;
 4136                 public Instruction* value;
 4137             }
 4138         }
 4139 
 4140         public class LocalInstructionRule : System.Text.Parsing.RuleParser
 4141         {
 4142             public LocalInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4143             {
 4144                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4145                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4146                 SetValueTypeName(ToUtf32("Instruction*"));
 4147             }
 4148             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4149             {
 4150                 parsingData->PushContext(Id(), new Context());
 4151                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4152                 UniquePtr<Object> result_value = stack.Pop();
 4153                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4154                 UniquePtr<Object> context_value = stack.Pop();
 4155                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4156             }
 4157             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4158             {
 4159                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4160                 if (matched)
 4161                 {
 4162                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4163                 }
 4164                 parsingData->PopContext(Id());
 4165             }
 4166             public override void Link()
 4167             {
 4168                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4169                 a0ActionParser->SetAction(A0Action);
 4170                 NonterminalParser* localTypeNonterminalParser = GetNonterminal(ToUtf32("localType"));
 4171                 localTypeNonterminalParser->SetPre(PrelocalType);
 4172                 localTypeNonterminalParser->SetPost(PostlocalType);
 4173             }
 4174             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4175             {
 4176                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4177                 context->value = new LocalInstruction(context->result, context->fromlocalType, span.lineNumber);
 4178             }
 4179             public void PrelocalType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4180             {
 4181                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4182                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4183             }
 4184             public void PostlocalType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4185             {
 4186                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4187                 if (matched)
 4188                 {
 4189                     UniquePtr<Object> fromlocalType_value = stack.Pop();
 4190                     context->fromlocalType = *cast<ValueObject<Type*>*>(fromlocalType_value.Get());
 4191                 }
 4192             }
 4193             public class Context : System.Text.Parsing.Context
 4194             {
 4195                 public Context() : context(), result(), value(), fromlocalType()
 4196                 {
 4197                 }
 4198                 public cmsx.intermediate.Context* context;
 4199                 public Value* result;
 4200                 public Instruction* value;
 4201                 public Type* fromlocalType;
 4202             }
 4203         }
 4204 
 4205         public class LoadInstructionRule : System.Text.Parsing.RuleParser
 4206         {
 4207             public LoadInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4208             {
 4209                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4210                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4211                 SetValueTypeName(ToUtf32("Instruction*"));
 4212             }
 4213             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4214             {
 4215                 parsingData->PushContext(Id(), new Context());
 4216                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4217                 UniquePtr<Object> result_value = stack.Pop();
 4218                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4219                 UniquePtr<Object> context_value = stack.Pop();
 4220                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4221             }
 4222             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4223             {
 4224                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4225                 if (matched)
 4226                 {
 4227                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4228                 }
 4229                 parsingData->PopContext(Id());
 4230             }
 4231             public override void Link()
 4232             {
 4233                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4234                 a0ActionParser->SetAction(A0Action);
 4235                 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
 4236                 ptrNonterminalParser->SetPre(Preptr);
 4237                 ptrNonterminalParser->SetPost(Postptr);
 4238             }
 4239             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4240             {
 4241                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4242                 context->value = new LoadInstruction(context->result, context->fromptr, span.lineNumber);
 4243             }
 4244             public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4245             {
 4246                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4247                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4248             }
 4249             public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4250             {
 4251                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4252                 if (matched)
 4253                 {
 4254                     UniquePtr<Object> fromptr_value = stack.Pop();
 4255                     context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
 4256                 }
 4257             }
 4258             public class Context : System.Text.Parsing.Context
 4259             {
 4260                 public Context() : context(), result(), value(), fromptr()
 4261                 {
 4262                 }
 4263                 public cmsx.intermediate.Context* context;
 4264                 public Value* result;
 4265                 public Instruction* value;
 4266                 public Value* fromptr;
 4267             }
 4268         }
 4269 
 4270         public class ElemAddrInstructionRule : System.Text.Parsing.RuleParser
 4271         {
 4272             public ElemAddrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4273             {
 4274                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4275                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4276                 SetValueTypeName(ToUtf32("Instruction*"));
 4277             }
 4278             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4279             {
 4280                 parsingData->PushContext(Id(), new Context());
 4281                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4282                 UniquePtr<Object> result_value = stack.Pop();
 4283                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4284                 UniquePtr<Object> context_value = stack.Pop();
 4285                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4286             }
 4287             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4288             {
 4289                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4290                 if (matched)
 4291                 {
 4292                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4293                 }
 4294                 parsingData->PopContext(Id());
 4295             }
 4296             public override void Link()
 4297             {
 4298                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4299                 a0ActionParser->SetAction(A0Action);
 4300                 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
 4301                 ptrNonterminalParser->SetPre(Preptr);
 4302                 ptrNonterminalParser->SetPost(Postptr);
 4303                 NonterminalParser* indexNonterminalParser = GetNonterminal(ToUtf32("index"));
 4304                 indexNonterminalParser->SetPre(Preindex);
 4305                 indexNonterminalParser->SetPost(Postindex);
 4306             }
 4307             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4308             {
 4309                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4310                 context->value = new ElemAddrInstruction(context->result, context->fromptr, context->fromindex, span.lineNumber);
 4311             }
 4312             public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4313             {
 4314                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4315                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4316             }
 4317             public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4318             {
 4319                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4320                 if (matched)
 4321                 {
 4322                     UniquePtr<Object> fromptr_value = stack.Pop();
 4323                     context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
 4324                 }
 4325             }
 4326             public void Preindex(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4327             {
 4328                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4329                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4330             }
 4331             public void Postindex(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4332             {
 4333                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4334                 if (matched)
 4335                 {
 4336                     UniquePtr<Object> fromindex_value = stack.Pop();
 4337                     context->fromindex = *cast<ValueObject<Value*>*>(fromindex_value.Get());
 4338                 }
 4339             }
 4340             public class Context : System.Text.Parsing.Context
 4341             {
 4342                 public Context() : context(), result(), value(), fromptr(), fromindex()
 4343                 {
 4344                 }
 4345                 public cmsx.intermediate.Context* context;
 4346                 public Value* result;
 4347                 public Instruction* value;
 4348                 public Value* fromptr;
 4349                 public Value* fromindex;
 4350             }
 4351         }
 4352 
 4353         public class PtrOffsetInstructionRule : System.Text.Parsing.RuleParser
 4354         {
 4355             public PtrOffsetInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4356             {
 4357                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4358                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4359                 SetValueTypeName(ToUtf32("Instruction*"));
 4360             }
 4361             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4362             {
 4363                 parsingData->PushContext(Id(), new Context());
 4364                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4365                 UniquePtr<Object> result_value = stack.Pop();
 4366                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4367                 UniquePtr<Object> context_value = stack.Pop();
 4368                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4369             }
 4370             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4371             {
 4372                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4373                 if (matched)
 4374                 {
 4375                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4376                 }
 4377                 parsingData->PopContext(Id());
 4378             }
 4379             public override void Link()
 4380             {
 4381                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4382                 a0ActionParser->SetAction(A0Action);
 4383                 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
 4384                 ptrNonterminalParser->SetPre(Preptr);
 4385                 ptrNonterminalParser->SetPost(Postptr);
 4386                 NonterminalParser* offsetNonterminalParser = GetNonterminal(ToUtf32("offset"));
 4387                 offsetNonterminalParser->SetPre(Preoffset);
 4388                 offsetNonterminalParser->SetPost(Postoffset);
 4389             }
 4390             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4391             {
 4392                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4393                 context->value = new PtrOffsetInstruction(context->result, context->fromptr, context->fromoffset, span.lineNumber);
 4394             }
 4395             public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4396             {
 4397                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4398                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4399             }
 4400             public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4401             {
 4402                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4403                 if (matched)
 4404                 {
 4405                     UniquePtr<Object> fromptr_value = stack.Pop();
 4406                     context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
 4407                 }
 4408             }
 4409             public void Preoffset(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4410             {
 4411                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4412                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4413             }
 4414             public void Postoffset(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4415             {
 4416                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4417                 if (matched)
 4418                 {
 4419                     UniquePtr<Object> fromoffset_value = stack.Pop();
 4420                     context->fromoffset = *cast<ValueObject<Value*>*>(fromoffset_value.Get());
 4421                 }
 4422             }
 4423             public class Context : System.Text.Parsing.Context
 4424             {
 4425                 public Context() : context(), result(), value(), fromptr(), fromoffset()
 4426                 {
 4427                 }
 4428                 public cmsx.intermediate.Context* context;
 4429                 public Value* result;
 4430                 public Instruction* value;
 4431                 public Value* fromptr;
 4432                 public Value* fromoffset;
 4433             }
 4434         }
 4435 
 4436         public class PtrDiffInstructionRule : System.Text.Parsing.RuleParser
 4437         {
 4438             public PtrDiffInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4439             {
 4440                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4441                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4442                 SetValueTypeName(ToUtf32("Instruction*"));
 4443             }
 4444             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4445             {
 4446                 parsingData->PushContext(Id(), new Context());
 4447                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4448                 UniquePtr<Object> result_value = stack.Pop();
 4449                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4450                 UniquePtr<Object> context_value = stack.Pop();
 4451                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4452             }
 4453             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4454             {
 4455                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4456                 if (matched)
 4457                 {
 4458                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4459                 }
 4460                 parsingData->PopContext(Id());
 4461             }
 4462             public override void Link()
 4463             {
 4464                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4465                 a0ActionParser->SetAction(A0Action);
 4466                 NonterminalParser* leftPtrNonterminalParser = GetNonterminal(ToUtf32("leftPtr"));
 4467                 leftPtrNonterminalParser->SetPre(PreleftPtr);
 4468                 leftPtrNonterminalParser->SetPost(PostleftPtr);
 4469                 NonterminalParser* rightPtrNonterminalParser = GetNonterminal(ToUtf32("rightPtr"));
 4470                 rightPtrNonterminalParser->SetPre(PrerightPtr);
 4471                 rightPtrNonterminalParser->SetPost(PostrightPtr);
 4472             }
 4473             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4474             {
 4475                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4476                 context->value = new PtrDiffInstruction(context->result, context->fromleftPtr, context->fromrightPtr, span.lineNumber);
 4477             }
 4478             public void PreleftPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4479             {
 4480                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4481                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4482             }
 4483             public void PostleftPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4484             {
 4485                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4486                 if (matched)
 4487                 {
 4488                     UniquePtr<Object> fromleftPtr_value = stack.Pop();
 4489                     context->fromleftPtr = *cast<ValueObject<Value*>*>(fromleftPtr_value.Get());
 4490                 }
 4491             }
 4492             public void PrerightPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4493             {
 4494                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4495                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4496             }
 4497             public void PostrightPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4498             {
 4499                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4500                 if (matched)
 4501                 {
 4502                     UniquePtr<Object> fromrightPtr_value = stack.Pop();
 4503                     context->fromrightPtr = *cast<ValueObject<Value*>*>(fromrightPtr_value.Get());
 4504                 }
 4505             }
 4506             public class Context : System.Text.Parsing.Context
 4507             {
 4508                 public Context() : context(), result(), value(), fromleftPtr(), fromrightPtr()
 4509                 {
 4510                 }
 4511                 public cmsx.intermediate.Context* context;
 4512                 public Value* result;
 4513                 public Instruction* value;
 4514                 public Value* fromleftPtr;
 4515                 public Value* fromrightPtr;
 4516             }
 4517         }
 4518 
 4519         public class FunctionCallInstructionRule : System.Text.Parsing.RuleParser
 4520         {
 4521             public FunctionCallInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4522             {
 4523                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4524                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4525                 SetValueTypeName(ToUtf32("Instruction*"));
 4526             }
 4527             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4528             {
 4529                 parsingData->PushContext(Id(), new Context());
 4530                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4531                 UniquePtr<Object> result_value = stack.Pop();
 4532                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4533                 UniquePtr<Object> context_value = stack.Pop();
 4534                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4535             }
 4536             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4537             {
 4538                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4539                 if (matched)
 4540                 {
 4541                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4542                 }
 4543                 parsingData->PopContext(Id());
 4544             }
 4545             public override void Link()
 4546             {
 4547                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4548                 a0ActionParser->SetAction(A0Action);
 4549                 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
 4550                 functionTypeNonterminalParser->SetPre(PrefunctionType);
 4551                 functionTypeNonterminalParser->SetPost(PostfunctionType);
 4552                 NonterminalParser* calleeNonterminalParser = GetNonterminal(ToUtf32("callee"));
 4553                 calleeNonterminalParser->SetPre(Precallee);
 4554                 calleeNonterminalParser->SetPost(Postcallee);
 4555             }
 4556             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4557             {
 4558                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4559                 context->value = new FunctionCallInstruction(context->result, context->fromcallee, span.lineNumber);
 4560             }
 4561             public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4562             {
 4563                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4564                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4565             }
 4566             public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4567             {
 4568                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4569                 if (matched)
 4570                 {
 4571                     UniquePtr<Object> fromfunctionType_value = stack.Pop();
 4572                     context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
 4573                 }
 4574             }
 4575             public void Precallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4576             {
 4577                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4578                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4579                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromfunctionType)));
 4580             }
 4581             public void Postcallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4582             {
 4583                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4584                 if (matched)
 4585                 {
 4586                     UniquePtr<Object> fromcallee_value = stack.Pop();
 4587                     context->fromcallee = *cast<ValueObject<Value*>*>(fromcallee_value.Get());
 4588                 }
 4589             }
 4590             public class Context : System.Text.Parsing.Context
 4591             {
 4592                 public Context() : context(), result(), value(), fromfunctionType(), fromcallee()
 4593                 {
 4594                 }
 4595                 public cmsx.intermediate.Context* context;
 4596                 public Value* result;
 4597                 public Instruction* value;
 4598                 public Type* fromfunctionType;
 4599                 public Value* fromcallee;
 4600             }
 4601         }
 4602 
 4603         public class TrapInstructionRule : System.Text.Parsing.RuleParser
 4604         {
 4605             public TrapInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4606             {
 4607                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4608                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4609                 SetValueTypeName(ToUtf32("Instruction*"));
 4610             }
 4611             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4612             {
 4613                 parsingData->PushContext(Id(), new Context());
 4614                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4615                 UniquePtr<Object> result_value = stack.Pop();
 4616                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4617                 UniquePtr<Object> context_value = stack.Pop();
 4618                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4619             }
 4620             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4621             {
 4622                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4623                 if (matched)
 4624                 {
 4625                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4626                 }
 4627                 parsingData->PopContext(Id());
 4628             }
 4629             public override void Link()
 4630             {
 4631                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4632                 a0ActionParser->SetAction(A0Action);
 4633                 NonterminalParser* type1NonterminalParser = GetNonterminal(ToUtf32("type1"));
 4634                 type1NonterminalParser->SetPre(Pretype1);
 4635                 type1NonterminalParser->SetPost(Posttype1);
 4636                 NonterminalParser* val1NonterminalParser = GetNonterminal(ToUtf32("val1"));
 4637                 val1NonterminalParser->SetPre(Preval1);
 4638                 val1NonterminalParser->SetPost(Postval1);
 4639                 NonterminalParser* type2NonterminalParser = GetNonterminal(ToUtf32("type2"));
 4640                 type2NonterminalParser->SetPre(Pretype2);
 4641                 type2NonterminalParser->SetPost(Posttype2);
 4642                 NonterminalParser* val2NonterminalParser = GetNonterminal(ToUtf32("val2"));
 4643                 val2NonterminalParser->SetPre(Preval2);
 4644                 val2NonterminalParser->SetPost(Postval2);
 4645                 NonterminalParser* type3NonterminalParser = GetNonterminal(ToUtf32("type3"));
 4646                 type3NonterminalParser->SetPre(Pretype3);
 4647                 type3NonterminalParser->SetPost(Posttype3);
 4648                 NonterminalParser* val3NonterminalParser = GetNonterminal(ToUtf32("val3"));
 4649                 val3NonterminalParser->SetPre(Preval3);
 4650                 val3NonterminalParser->SetPost(Postval3);
 4651             }
 4652             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4653             {
 4654                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4655                 context->value = new TrapInstruction(context->result, context->fromval1, context->fromval2, context->fromval3, span.lineNumber);
 4656             }
 4657             public void Pretype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4658             {
 4659                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4660                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4661             }
 4662             public void Posttype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4663             {
 4664                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4665                 if (matched)
 4666                 {
 4667                     UniquePtr<Object> fromtype1_value = stack.Pop();
 4668                     context->fromtype1 = *cast<ValueObject<Type*>*>(fromtype1_value.Get());
 4669                 }
 4670             }
 4671             public void Preval1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4672             {
 4673                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4674                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4675                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype1)));
 4676             }
 4677             public void Postval1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4678             {
 4679                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4680                 if (matched)
 4681                 {
 4682                     UniquePtr<Object> fromval1_value = stack.Pop();
 4683                     context->fromval1 = *cast<ValueObject<Value*>*>(fromval1_value.Get());
 4684                 }
 4685             }
 4686             public void Pretype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4687             {
 4688                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4689                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4690             }
 4691             public void Posttype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4692             {
 4693                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4694                 if (matched)
 4695                 {
 4696                     UniquePtr<Object> fromtype2_value = stack.Pop();
 4697                     context->fromtype2 = *cast<ValueObject<Type*>*>(fromtype2_value.Get());
 4698                 }
 4699             }
 4700             public void Preval2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4701             {
 4702                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4703                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4704                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype2)));
 4705             }
 4706             public void Postval2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4707             {
 4708                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4709                 if (matched)
 4710                 {
 4711                     UniquePtr<Object> fromval2_value = stack.Pop();
 4712                     context->fromval2 = *cast<ValueObject<Value*>*>(fromval2_value.Get());
 4713                 }
 4714             }
 4715             public void Pretype3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4716             {
 4717                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4718                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4719             }
 4720             public void Posttype3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4721             {
 4722                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4723                 if (matched)
 4724                 {
 4725                     UniquePtr<Object> fromtype3_value = stack.Pop();
 4726                     context->fromtype3 = *cast<ValueObject<Type*>*>(fromtype3_value.Get());
 4727                 }
 4728             }
 4729             public void Preval3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4730             {
 4731                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4732                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4733                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype3)));
 4734             }
 4735             public void Postval3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4736             {
 4737                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4738                 if (matched)
 4739                 {
 4740                     UniquePtr<Object> fromval3_value = stack.Pop();
 4741                     context->fromval3 = *cast<ValueObject<Value*>*>(fromval3_value.Get());
 4742                 }
 4743             }
 4744             public class Context : System.Text.Parsing.Context
 4745             {
 4746                 public Context() : context(), result(), value(), fromtype1(), fromval1(), fromtype2(), fromval2(), fromtype3(), fromval3()
 4747                 {
 4748                 }
 4749                 public cmsx.intermediate.Context* context;
 4750                 public Value* result;
 4751                 public Instruction* value;
 4752                 public Type* fromtype1;
 4753                 public Value* fromval1;
 4754                 public Type* fromtype2;
 4755                 public Value* fromval2;
 4756                 public Type* fromtype3;
 4757                 public Value* fromval3;
 4758             }
 4759         }
 4760 
 4761         public class OperandRule : System.Text.Parsing.RuleParser
 4762         {
 4763             public OperandRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4764             {
 4765                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4766                 SetValueTypeName(ToUtf32("Value*"));
 4767             }
 4768             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4769             {
 4770                 parsingData->PushContext(Id(), new Context());
 4771                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4772                 UniquePtr<Object> context_value = stack.Pop();
 4773                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4774             }
 4775             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4776             {
 4777                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4778                 if (matched)
 4779                 {
 4780                     stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
 4781                 }
 4782                 parsingData->PopContext(Id());
 4783             }
 4784             public override void Link()
 4785             {
 4786                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4787                 a0ActionParser->SetAction(A0Action);
 4788                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 4789                 typeNonterminalParser->SetPre(Pretype);
 4790                 typeNonterminalParser->SetPost(Posttype);
 4791                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 4792                 valNonterminalParser->SetPre(Preval);
 4793                 valNonterminalParser->SetPost(Postval);
 4794             }
 4795             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4796             {
 4797                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4798                 context->value = context->fromval;
 4799             }
 4800             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4801             {
 4802                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4803                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4804             }
 4805             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4806             {
 4807                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4808                 if (matched)
 4809                 {
 4810                     UniquePtr<Object> fromtype_value = stack.Pop();
 4811                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 4812                 }
 4813             }
 4814             public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4815             {
 4816                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4817                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4818                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 4819             }
 4820             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4821             {
 4822                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4823                 if (matched)
 4824                 {
 4825                     UniquePtr<Object> fromval_value = stack.Pop();
 4826                     context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
 4827                 }
 4828             }
 4829             public class Context : System.Text.Parsing.Context
 4830             {
 4831                 public Context() : context(), value(), fromtype(), fromval()
 4832                 {
 4833                 }
 4834                 public cmsx.intermediate.Context* context;
 4835                 public Value* value;
 4836                 public Type* fromtype;
 4837                 public Value* fromval;
 4838             }
 4839         }
 4840 
 4841         public class LabelRule : System.Text.Parsing.RuleParser
 4842         {
 4843             public LabelRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4844             {
 4845                 SetValueTypeName(ToUtf32("uint"));
 4846             }
 4847             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4848             {
 4849                 parsingData->PushContext(Id(), new Context());
 4850                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4851             }
 4852             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4853             {
 4854                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4855                 if (matched)
 4856                 {
 4857                     stack.Push(UniquePtr<Object>(new ValueObject<uint>(context->value)));
 4858                 }
 4859                 parsingData->PopContext(Id());
 4860             }
 4861             public override void Link()
 4862             {
 4863                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4864                 a0ActionParser->SetAction(A0Action);
 4865                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 4866                 xNonterminalParser->SetPost(Postx);
 4867             }
 4868             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4869             {
 4870                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4871                 context->value = context->fromx;
 4872             }
 4873             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4874             {
 4875                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4876                 if (matched)
 4877                 {
 4878                     UniquePtr<Object> fromx_value = stack.Pop();
 4879                     context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
 4880                 }
 4881             }
 4882             public class Context : System.Text.Parsing.Context
 4883             {
 4884                 public Context() : value(), fromx()
 4885                 {
 4886                 }
 4887                 public uint value;
 4888                 public uint fromx;
 4889             }
 4890         }
 4891 
 4892         public class ValueRule : System.Text.Parsing.RuleParser
 4893         {
 4894             public ValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4895             {
 4896                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4897                 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
 4898                 SetValueTypeName(ToUtf32("Value*"));
 4899             }
 4900             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4901             {
 4902                 parsingData->PushContext(Id(), new Context());
 4903                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4904                 UniquePtr<Object> type_value = stack.Pop();
 4905                 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
 4906                 UniquePtr<Object> context_value = stack.Pop();
 4907                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4908             }
 4909             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4910             {
 4911                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4912                 if (matched)
 4913                 {
 4914                     stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
 4915                 }
 4916                 parsingData->PopContext(Id());
 4917             }
 4918             public override void Link()
 4919             {
 4920                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4921                 a0ActionParser->SetAction(A0Action);
 4922                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 4923                 a1ActionParser->SetAction(A1Action);
 4924                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 4925                 a2ActionParser->SetAction(A2Action);
 4926                 NonterminalParser* idValueNonterminalParser = GetNonterminal(ToUtf32("IdValue"));
 4927                 idValueNonterminalParser->SetPre(PreIdValue);
 4928                 idValueNonterminalParser->SetPost(PostIdValue);
 4929                 NonterminalParser* symbolValueNonterminalParser = GetNonterminal(ToUtf32("SymbolValue"));
 4930                 symbolValueNonterminalParser->SetPre(PreSymbolValue);
 4931                 symbolValueNonterminalParser->SetPost(PostSymbolValue);
 4932                 NonterminalParser* literalValueNonterminalParser = GetNonterminal(ToUtf32("LiteralValue"));
 4933                 literalValueNonterminalParser->SetPre(PreLiteralValue);
 4934                 literalValueNonterminalParser->SetPost(PostLiteralValue);
 4935             }
 4936             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4937             {
 4938                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4939                 context->value = context->fromIdValue;
 4940             }
 4941             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4942             {
 4943                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4944                 context->value = context->fromSymbolValue;
 4945             }
 4946             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4947             {
 4948                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4949                 context->value = context->fromLiteralValue;
 4950             }
 4951             public void PreIdValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4952             {
 4953                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4954                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4955                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
 4956             }
 4957             public void PostIdValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4958             {
 4959                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4960                 if (matched)
 4961                 {
 4962                     UniquePtr<Object> fromIdValue_value = stack.Pop();
 4963                     context->fromIdValue = *cast<ValueObject<Value*>*>(fromIdValue_value.Get());
 4964                 }
 4965             }
 4966             public void PreSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4967             {
 4968                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4969                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4970                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
 4971             }
 4972             public void PostSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4973             {
 4974                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4975                 if (matched)
 4976                 {
 4977                     UniquePtr<Object> fromSymbolValue_value = stack.Pop();
 4978                     context->fromSymbolValue = *cast<ValueObject<Value*>*>(fromSymbolValue_value.Get());
 4979                 }
 4980             }
 4981             public void PreLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4982             {
 4983                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4984                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4985                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
 4986             }
 4987             public void PostLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4988             {
 4989                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4990                 if (matched)
 4991                 {
 4992                     UniquePtr<Object> fromLiteralValue_value = stack.Pop();
 4993                     context->fromLiteralValue = *cast<ValueObject<Value*>*>(fromLiteralValue_value.Get());
 4994                 }
 4995             }
 4996             public class Context : System.Text.Parsing.Context
 4997             {
 4998                 public Context() : context(), type(), value(), fromIdValue(), fromSymbolValue(), fromLiteralValue()
 4999                 {
 5000                 }
 5001                 public cmsx.intermediate.Context* context;
 5002                 public Type* type;
 5003                 public Value* value;
 5004                 public Value* fromIdValue;
 5005                 public Value* fromSymbolValue;
 5006                 public Value* fromLiteralValue;
 5007             }
 5008         }
 5009 
 5010         public class IdValueRule : System.Text.Parsing.RuleParser
 5011         {
 5012             public IdValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5013             {
 5014                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5015                 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
 5016                 SetValueTypeName(ToUtf32("Value*"));
 5017             }
 5018             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5019             {
 5020                 parsingData->PushContext(Id(), new Context());
 5021                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5022                 UniquePtr<Object> type_value = stack.Pop();
 5023                 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
 5024                 UniquePtr<Object> context_value = stack.Pop();
 5025                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5026             }
 5027             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5028             {
 5029                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5030                 if (matched)
 5031                 {
 5032                     stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
 5033                 }
 5034                 parsingData->PopContext(Id());
 5035             }
 5036             public override void Link()
 5037             {
 5038                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5039                 a0ActionParser->SetAction(A0Action);
 5040                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 5041                 xNonterminalParser->SetPost(Postx);
 5042             }
 5043             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5044             {
 5045                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5046                 context->value = context->context->currentFunction->MakeIdValue(span.lineNumber, context->fromx, context->type);
 5047             }
 5048             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5049             {
 5050                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5051                 if (matched)
 5052                 {
 5053                     UniquePtr<Object> fromx_value = stack.Pop();
 5054                     context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
 5055                 }
 5056             }
 5057             public class Context : System.Text.Parsing.Context
 5058             {
 5059                 public Context() : context(), type(), value(), fromx()
 5060                 {
 5061                 }
 5062                 public cmsx.intermediate.Context* context;
 5063                 public Type* type;
 5064                 public Value* value;
 5065                 public uint fromx;
 5066             }
 5067         }
 5068 
 5069         public class SymbolValueRule : System.Text.Parsing.RuleParser
 5070         {
 5071             public SymbolValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5072             {
 5073                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5074                 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
 5075                 SetValueTypeName(ToUtf32("Value*"));
 5076             }
 5077             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5078             {
 5079                 parsingData->PushContext(Id(), new Context());
 5080                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5081                 UniquePtr<Object> type_value = stack.Pop();
 5082                 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
 5083                 UniquePtr<Object> context_value = stack.Pop();
 5084                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5085             }
 5086             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5087             {
 5088                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5089                 if (matched)
 5090                 {
 5091                     stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
 5092                 }
 5093                 parsingData->PopContext(Id());
 5094             }
 5095             public override void Link()
 5096             {
 5097                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5098                 a0ActionParser->SetAction(A0Action);
 5099                 NonterminalParser* identifierNonterminalParser = GetNonterminal(ToUtf32("identifier"));
 5100                 identifierNonterminalParser->SetPost(Postidentifier);
 5101             }
 5102             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5103             {
 5104                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5105                 context->value = context->context->MakeSymbolValue(span.lineNumber, ToUtf8(context->fromidentifier), context->type);
 5106             }
 5107             public void Postidentifier(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5108             {
 5109                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5110                 if (matched)
 5111                 {
 5112                     UniquePtr<Object> fromidentifier_value = stack.Pop();
 5113                     context->fromidentifier = *cast<ValueObject<ustring>*>(fromidentifier_value.Get());
 5114                 }
 5115             }
 5116             public class Context : System.Text.Parsing.Context
 5117             {
 5118                 public Context() : context(), type(), value(), fromidentifier()
 5119                 {
 5120                 }
 5121                 public cmsx.intermediate.Context* context;
 5122                 public Type* type;
 5123                 public Value* value;
 5124                 public ustring fromidentifier;
 5125             }
 5126         }
 5127 
 5128         public class LiteralValueRule : System.Text.Parsing.RuleParser
 5129         {
 5130             public LiteralValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5131             {
 5132                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5133                 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
 5134                 SetValueTypeName(ToUtf32("Value*"));
 5135             }
 5136             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5137             {
 5138                 parsingData->PushContext(Id(), new Context());
 5139                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5140                 UniquePtr<Object> type_value = stack.Pop();
 5141                 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
 5142                 UniquePtr<Object> context_value = stack.Pop();
 5143                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5144             }
 5145             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5146             {
 5147                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5148                 if (matched)
 5149                 {
 5150                     stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
 5151                 }
 5152                 parsingData->PopContext(Id());
 5153             }
 5154             public override void Link()
 5155             {
 5156                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5157                 a0ActionParser->SetAction(A0Action);
 5158             }
 5159             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5160             {
 5161                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5162                 context->value = context->context->MakeLiteralValue(span.lineNumber, ToUtf8(ustring(matchBegin, matchEnd)), context->type);
 5163             }
 5164             public class Context : System.Text.Parsing.Context
 5165             {
 5166                 public Context() : context(), type(), value()
 5167                 {
 5168                 }
 5169                 public cmsx.intermediate.Context* context;
 5170                 public Type* type;
 5171                 public Value* value;
 5172             }
 5173         }
 5174 
 5175         public class TypeDeclarationRule : System.Text.Parsing.RuleParser
 5176         {
 5177             public TypeDeclarationRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5178             {
 5179                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5180             }
 5181             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5182             {
 5183                 parsingData->PushContext(Id(), new Context());
 5184                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5185                 UniquePtr<Object> context_value = stack.Pop();
 5186                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5187             }
 5188             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5189             {
 5190                 parsingData->PopContext(Id());
 5191             }
 5192             public override void Link()
 5193             {
 5194                 NonterminalParser* typeIdNonterminalParser = GetNonterminal(ToUtf32("typeId"));
 5195                 typeIdNonterminalParser->SetPre(PretypeId);
 5196                 typeIdNonterminalParser->SetPost(PosttypeId);
 5197                 NonterminalParser* structureTypeNonterminalParser = GetNonterminal(ToUtf32("StructureType"));
 5198                 structureTypeNonterminalParser->SetPre(PreStructureType);
 5199                 NonterminalParser* arrayTypeNonterminalParser = GetNonterminal(ToUtf32("ArrayType"));
 5200                 arrayTypeNonterminalParser->SetPre(PreArrayType);
 5201                 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("FunctionType"));
 5202                 functionTypeNonterminalParser->SetPre(PreFunctionType);
 5203             }
 5204             public void PretypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5205             {
 5206                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5207                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5208             }
 5209             public void PosttypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5210             {
 5211                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5212                 if (matched)
 5213                 {
 5214                     UniquePtr<Object> fromtypeId_value = stack.Pop();
 5215                     context->fromtypeId = *cast<ValueObject<string>*>(fromtypeId_value.Get());
 5216                 }
 5217             }
 5218             public void PreStructureType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5219             {
 5220                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5221                 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
 5222                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5223             }
 5224             public void PreArrayType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5225             {
 5226                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5227                 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
 5228                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5229             }
 5230             public void PreFunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5231             {
 5232                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5233                 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
 5234                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5235             }
 5236             public class Context : System.Text.Parsing.Context
 5237             {
 5238                 public Context() : context(), fromtypeId()
 5239                 {
 5240                 }
 5241                 public cmsx.intermediate.Context* context;
 5242                 public string fromtypeId;
 5243             }
 5244         }
 5245 
 5246         public class StructureTypeRule : System.Text.Parsing.RuleParser
 5247         {
 5248             public StructureTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5249             {
 5250                 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
 5251                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5252                 AddLocalVariable(AttrOrVar(ToUtf32("List<string>"), ToUtf32("memberTypeIds")));
 5253             }
 5254             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5255             {
 5256                 parsingData->PushContext(Id(), new Context());
 5257                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5258                 UniquePtr<Object> context_value = stack.Pop();
 5259                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5260                 UniquePtr<Object> typeId_value = stack.Pop();
 5261                 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
 5262             }
 5263             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5264             {
 5265                 parsingData->PopContext(Id());
 5266             }
 5267             public override void Link()
 5268             {
 5269                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5270                 a0ActionParser->SetAction(A0Action);
 5271                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 5272                 a1ActionParser->SetAction(A1Action);
 5273                 NonterminalParser* strTypeIdNonterminalParser = GetNonterminal(ToUtf32("StrTypeId"));
 5274                 strTypeIdNonterminalParser->SetPre(PreStrTypeId);
 5275                 strTypeIdNonterminalParser->SetPost(PostStrTypeId);
 5276                 NonterminalParser* longNonterminalParser = GetNonterminal(ToUtf32("long"));
 5277                 longNonterminalParser->SetPost(Postlong);
 5278                 NonterminalParser* szNonterminalParser = GetNonterminal(ToUtf32("sz"));
 5279                 szNonterminalParser->SetPost(Postsz);
 5280                 NonterminalParser* alNonterminalParser = GetNonterminal(ToUtf32("al"));
 5281                 alNonterminalParser->SetPost(Postal);
 5282             }
 5283             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5284             {
 5285                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5286                 context->context->AddStructureType(context->typeId, context->memberTypeIds);
 5287             }
 5288             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5289             {
 5290                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5291                 context->memberTypeIds.Add(context->fromStrTypeId);
 5292             }
 5293             public void PreStrTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5294             {
 5295                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5296                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5297             }
 5298             public void PostStrTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5299             {
 5300                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5301                 if (matched)
 5302                 {
 5303                     UniquePtr<Object> fromStrTypeId_value = stack.Pop();
 5304                     context->fromStrTypeId = *cast<ValueObject<string>*>(fromStrTypeId_value.Get());
 5305                 }
 5306             }
 5307             public void Postlong(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5308             {
 5309                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5310                 if (matched)
 5311                 {
 5312                     UniquePtr<Object> fromlong_value = stack.Pop();
 5313                     context->fromlong = *cast<ValueObject<long>*>(fromlong_value.Get());
 5314                 }
 5315             }
 5316             public void Postsz(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5317             {
 5318                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5319                 if (matched)
 5320                 {
 5321                     UniquePtr<Object> fromsz_value = stack.Pop();
 5322                     context->fromsz = *cast<ValueObject<long>*>(fromsz_value.Get());
 5323                 }
 5324             }
 5325             public void Postal(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5326             {
 5327                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5328                 if (matched)
 5329                 {
 5330                     UniquePtr<Object> fromal_value = stack.Pop();
 5331                     context->fromal = *cast<ValueObject<long>*>(fromal_value.Get());
 5332                 }
 5333             }
 5334             public class Context : System.Text.Parsing.Context
 5335             {
 5336                 public Context() : typeId(), context(), memberTypeIds(), fromStrTypeId(), fromlong(), fromsz(), fromal()
 5337                 {
 5338                 }
 5339                 public string typeId;
 5340                 public cmsx.intermediate.Context* context;
 5341                 public List<string> memberTypeIds;
 5342                 public string fromStrTypeId;
 5343                 public long fromlong;
 5344                 public long fromsz;
 5345                 public long fromal;
 5346             }
 5347         }
 5348 
 5349         public class ArrayTypeRule : System.Text.Parsing.RuleParser
 5350         {
 5351             public ArrayTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5352             {
 5353                 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
 5354                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5355             }
 5356             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5357             {
 5358                 parsingData->PushContext(Id(), new Context());
 5359                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5360                 UniquePtr<Object> context_value = stack.Pop();
 5361                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5362                 UniquePtr<Object> typeId_value = stack.Pop();
 5363                 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
 5364             }
 5365             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5366             {
 5367                 parsingData->PopContext(Id());
 5368             }
 5369             public override void Link()
 5370             {
 5371                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5372                 a0ActionParser->SetAction(A0Action);
 5373                 NonterminalParser* sizeNonterminalParser = GetNonterminal(ToUtf32("size"));
 5374                 sizeNonterminalParser->SetPost(Postsize);
 5375                 NonterminalParser* elementTypeIdNonterminalParser = GetNonterminal(ToUtf32("elementTypeId"));
 5376                 elementTypeIdNonterminalParser->SetPre(PreelementTypeId);
 5377                 elementTypeIdNonterminalParser->SetPost(PostelementTypeId);
 5378                 NonterminalParser* szNonterminalParser = GetNonterminal(ToUtf32("sz"));
 5379                 szNonterminalParser->SetPost(Postsz);
 5380                 NonterminalParser* alNonterminalParser = GetNonterminal(ToUtf32("al"));
 5381                 alNonterminalParser->SetPost(Postal);
 5382             }
 5383             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5384             {
 5385                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5386                 context->context->AddArrayType(context->typeId, context->fromelementTypeId, context->fromsize);
 5387             }
 5388             public void Postsize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5389             {
 5390                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5391                 if (matched)
 5392                 {
 5393                     UniquePtr<Object> fromsize_value = stack.Pop();
 5394                     context->fromsize = *cast<ValueObject<long>*>(fromsize_value.Get());
 5395                 }
 5396             }
 5397             public void PreelementTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5398             {
 5399                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5400                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5401             }
 5402             public void PostelementTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5403             {
 5404                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5405                 if (matched)
 5406                 {
 5407                     UniquePtr<Object> fromelementTypeId_value = stack.Pop();
 5408                     context->fromelementTypeId = *cast<ValueObject<string>*>(fromelementTypeId_value.Get());
 5409                 }
 5410             }
 5411             public void Postsz(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5412             {
 5413                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5414                 if (matched)
 5415                 {
 5416                     UniquePtr<Object> fromsz_value = stack.Pop();
 5417                     context->fromsz = *cast<ValueObject<long>*>(fromsz_value.Get());
 5418                 }
 5419             }
 5420             public void Postal(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5421             {
 5422                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5423                 if (matched)
 5424                 {
 5425                     UniquePtr<Object> fromal_value = stack.Pop();
 5426                     context->fromal = *cast<ValueObject<long>*>(fromal_value.Get());
 5427                 }
 5428             }
 5429             public class Context : System.Text.Parsing.Context
 5430             {
 5431                 public Context() : typeId(), context(), fromsize(), fromelementTypeId(), fromsz(), fromal()
 5432                 {
 5433                 }
 5434                 public string typeId;
 5435                 public cmsx.intermediate.Context* context;
 5436                 public long fromsize;
 5437                 public string fromelementTypeId;
 5438                 public long fromsz;
 5439                 public long fromal;
 5440             }
 5441         }
 5442 
 5443         public class FunctionTypeRule : System.Text.Parsing.RuleParser
 5444         {
 5445             public FunctionTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5446             {
 5447                 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
 5448                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5449                 AddLocalVariable(AttrOrVar(ToUtf32("List<string>"), ToUtf32("paramTypeIds")));
 5450             }
 5451             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5452             {
 5453                 parsingData->PushContext(Id(), new Context());
 5454                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5455                 UniquePtr<Object> context_value = stack.Pop();
 5456                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5457                 UniquePtr<Object> typeId_value = stack.Pop();
 5458                 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
 5459             }
 5460             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5461             {
 5462                 parsingData->PopContext(Id());
 5463             }
 5464             public override void Link()
 5465             {
 5466                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5467                 a0ActionParser->SetAction(A0Action);
 5468                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 5469                 a1ActionParser->SetAction(A1Action);
 5470                 NonterminalParser* returnTypeIdNonterminalParser = GetNonterminal(ToUtf32("returnTypeId"));
 5471                 returnTypeIdNonterminalParser->SetPre(PrereturnTypeId);
 5472                 returnTypeIdNonterminalParser->SetPost(PostreturnTypeId);
 5473                 NonterminalParser* paramTypeNonterminalParser = GetNonterminal(ToUtf32("paramType"));
 5474                 paramTypeNonterminalParser->SetPre(PreparamType);
 5475                 paramTypeNonterminalParser->SetPost(PostparamType);
 5476             }
 5477             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5478             {
 5479                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5480                 context->context->AddFunctionType(context->typeId, context->fromreturnTypeId, context->paramTypeIds);
 5481             }
 5482             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5483             {
 5484                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5485                 context->paramTypeIds.Add(context->fromparamType);
 5486             }
 5487             public void PrereturnTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5488             {
 5489                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5490                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5491             }
 5492             public void PostreturnTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5493             {
 5494                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5495                 if (matched)
 5496                 {
 5497                     UniquePtr<Object> fromreturnTypeId_value = stack.Pop();
 5498                     context->fromreturnTypeId = *cast<ValueObject<string>*>(fromreturnTypeId_value.Get());
 5499                 }
 5500             }
 5501             public void PreparamType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5502             {
 5503                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5504                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5505             }
 5506             public void PostparamType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5507             {
 5508                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5509                 if (matched)
 5510                 {
 5511                     UniquePtr<Object> fromparamType_value = stack.Pop();
 5512                     context->fromparamType = *cast<ValueObject<string>*>(fromparamType_value.Get());
 5513                 }
 5514             }
 5515             public class Context : System.Text.Parsing.Context
 5516             {
 5517                 public Context() : typeId(), context(), paramTypeIds(), fromreturnTypeId(), fromparamType()
 5518                 {
 5519                 }
 5520                 public string typeId;
 5521                 public cmsx.intermediate.Context* context;
 5522                 public List<string> paramTypeIds;
 5523                 public string fromreturnTypeId;
 5524                 public string fromparamType;
 5525             }
 5526         }
 5527 
 5528         public class StrTypeIdRule : System.Text.Parsing.RuleParser
 5529         {
 5530             public StrTypeIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5531             {
 5532                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5533                 SetValueTypeName(ToUtf32("string"));
 5534             }
 5535             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5536             {
 5537                 parsingData->PushContext(Id(), new Context());
 5538                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5539                 UniquePtr<Object> context_value = stack.Pop();
 5540                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5541             }
 5542             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5543             {
 5544                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5545                 if (matched)
 5546                 {
 5547                     stack.Push(UniquePtr<Object>(new ValueObject<string>(context->value)));
 5548                 }
 5549                 parsingData->PopContext(Id());
 5550             }
 5551             public override void Link()
 5552             {
 5553                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5554                 a0ActionParser->SetAction(A0Action);
 5555                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 5556                 a1ActionParser->SetAction(A1Action);
 5557                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 5558                 a2ActionParser->SetAction(A2Action);
 5559                 NonterminalParser* uintNonterminalParser = GetNonterminal(ToUtf32("uint"));
 5560                 uintNonterminalParser->SetPost(Postuint);
 5561             }
 5562             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5563             {
 5564                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5565                 context->value = ToUtf8(ustring(matchBegin, matchEnd));
 5566             }
 5567             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5568             {
 5569                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5570                 context->value = ToUtf8(ustring(matchBegin, matchEnd));
 5571             }
 5572             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5573             {
 5574                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5575                 context->value.Append('*');
 5576                 context->context->AddPtrType(context->value);
 5577             }
 5578             public void Postuint(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5579             {
 5580                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5581                 if (matched)
 5582                 {
 5583                     UniquePtr<Object> fromuint_value = stack.Pop();
 5584                     context->fromuint = *cast<ValueObject<uint>*>(fromuint_value.Get());
 5585                 }
 5586             }
 5587             public class Context : System.Text.Parsing.Context
 5588             {
 5589                 public Context() : context(), value(), fromuint()
 5590                 {
 5591                 }
 5592                 public cmsx.intermediate.Context* context;
 5593                 public string value;
 5594                 public uint fromuint;
 5595             }
 5596         }
 5597 
 5598         public class TypeExprRule : System.Text.Parsing.RuleParser
 5599         {
 5600             public TypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5601             {
 5602                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5603                 SetValueTypeName(ToUtf32("Type*"));
 5604             }
 5605             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5606             {
 5607                 parsingData->PushContext(Id(), new Context());
 5608                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5609                 UniquePtr<Object> context_value = stack.Pop();
 5610                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5611             }
 5612             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5613             {
 5614                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5615                 if (matched)
 5616                 {
 5617                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 5618                 }
 5619                 parsingData->PopContext(Id());
 5620             }
 5621             public override void Link()
 5622             {
 5623                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5624                 a0ActionParser->SetAction(A0Action);
 5625                 NonterminalParser* postfixTypeExprNonterminalParser = GetNonterminal(ToUtf32("PostfixTypeExpr"));
 5626                 postfixTypeExprNonterminalParser->SetPre(PrePostfixTypeExpr);
 5627                 postfixTypeExprNonterminalParser->SetPost(PostPostfixTypeExpr);
 5628             }
 5629             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5630             {
 5631                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5632                 context->value = context->fromPostfixTypeExpr;
 5633             }
 5634             public void PrePostfixTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5635             {
 5636                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5637                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5638             }
 5639             public void PostPostfixTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5640             {
 5641                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5642                 if (matched)
 5643                 {
 5644                     UniquePtr<Object> fromPostfixTypeExpr_value = stack.Pop();
 5645                     context->fromPostfixTypeExpr = *cast<ValueObject<Type*>*>(fromPostfixTypeExpr_value.Get());
 5646                 }
 5647             }
 5648             public class Context : System.Text.Parsing.Context
 5649             {
 5650                 public Context() : context(), value(), fromPostfixTypeExpr()
 5651                 {
 5652                 }
 5653                 public cmsx.intermediate.Context* context;
 5654                 public Type* value;
 5655                 public Type* fromPostfixTypeExpr;
 5656             }
 5657         }
 5658 
 5659         public class PostfixTypeExprRule : System.Text.Parsing.RuleParser
 5660         {
 5661             public PostfixTypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5662             {
 5663                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5664                 SetValueTypeName(ToUtf32("Type*"));
 5665             }
 5666             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5667             {
 5668                 parsingData->PushContext(Id(), new Context());
 5669                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5670                 UniquePtr<Object> context_value = stack.Pop();
 5671                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5672             }
 5673             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5674             {
 5675                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5676                 if (matched)
 5677                 {
 5678                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 5679                 }
 5680                 parsingData->PopContext(Id());
 5681             }
 5682             public override void Link()
 5683             {
 5684                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5685                 a0ActionParser->SetAction(A0Action);
 5686                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 5687                 a1ActionParser->SetAction(A1Action);
 5688                 NonterminalParser* primaryTypeExprNonterminalParser = GetNonterminal(ToUtf32("PrimaryTypeExpr"));
 5689                 primaryTypeExprNonterminalParser->SetPre(PrePrimaryTypeExpr);
 5690                 primaryTypeExprNonterminalParser->SetPost(PostPrimaryTypeExpr);
 5691             }
 5692             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5693             {
 5694                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5695                 context->value = context->fromPrimaryTypeExpr;
 5696             }
 5697             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5698             {
 5699                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5700                 context->value = context->context->GetPtrType(context->value);
 5701             }
 5702             public void PrePrimaryTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5703             {
 5704                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5705                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5706             }
 5707             public void PostPrimaryTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5708             {
 5709                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5710                 if (matched)
 5711                 {
 5712                     UniquePtr<Object> fromPrimaryTypeExpr_value = stack.Pop();
 5713                     context->fromPrimaryTypeExpr = *cast<ValueObject<Type*>*>(fromPrimaryTypeExpr_value.Get());
 5714                 }
 5715             }
 5716             public class Context : System.Text.Parsing.Context
 5717             {
 5718                 public Context() : context(), value(), fromPrimaryTypeExpr()
 5719                 {
 5720                 }
 5721                 public cmsx.intermediate.Context* context;
 5722                 public Type* value;
 5723                 public Type* fromPrimaryTypeExpr;
 5724             }
 5725         }
 5726 
 5727         public class PrimaryTypeExprRule : System.Text.Parsing.RuleParser
 5728         {
 5729             public PrimaryTypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5730             {
 5731                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5732                 SetValueTypeName(ToUtf32("Type*"));
 5733             }
 5734             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5735             {
 5736                 parsingData->PushContext(Id(), new Context());
 5737                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5738                 UniquePtr<Object> context_value = stack.Pop();
 5739                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5740             }
 5741             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5742             {
 5743                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5744                 if (matched)
 5745                 {
 5746                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 5747                 }
 5748                 parsingData->PopContext(Id());
 5749             }
 5750             public override void Link()
 5751             {
 5752                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5753                 a0ActionParser->SetAction(A0Action);
 5754                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 5755                 a1ActionParser->SetAction(A1Action);
 5756                 NonterminalParser* typeIdNonterminalParser = GetNonterminal(ToUtf32("TypeId"));
 5757                 typeIdNonterminalParser->SetPre(PreTypeId);
 5758                 typeIdNonterminalParser->SetPost(PostTypeId);
 5759                 NonterminalParser* primitiveTypeNonterminalParser = GetNonterminal(ToUtf32("PrimitiveType"));
 5760                 primitiveTypeNonterminalParser->SetPre(PrePrimitiveType);
 5761                 primitiveTypeNonterminalParser->SetPost(PostPrimitiveType);
 5762             }
 5763             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5764             {
 5765                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5766                 context->value = context->fromTypeId;
 5767             }
 5768             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5769             {
 5770                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5771                 context->value = context->fromPrimitiveType;
 5772             }
 5773             public void PreTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5774             {
 5775                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5776                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5777             }
 5778             public void PostTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5779             {
 5780                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5781                 if (matched)
 5782                 {
 5783                     UniquePtr<Object> fromTypeId_value = stack.Pop();
 5784                     context->fromTypeId = *cast<ValueObject<Type*>*>(fromTypeId_value.Get());
 5785                 }
 5786             }
 5787             public void PrePrimitiveType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5788             {
 5789                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5790                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5791             }
 5792             public void PostPrimitiveType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5793             {
 5794                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5795                 if (matched)
 5796                 {
 5797                     UniquePtr<Object> fromPrimitiveType_value = stack.Pop();
 5798                     context->fromPrimitiveType = *cast<ValueObject<Type*>*>(fromPrimitiveType_value.Get());
 5799                 }
 5800             }
 5801             public class Context : System.Text.Parsing.Context
 5802             {
 5803                 public Context() : context(), value(), fromTypeId(), fromPrimitiveType()
 5804                 {
 5805                 }
 5806                 public cmsx.intermediate.Context* context;
 5807                 public Type* value;
 5808                 public Type* fromTypeId;
 5809                 public Type* fromPrimitiveType;
 5810             }
 5811         }
 5812 
 5813         public class TypeIdRule : System.Text.Parsing.RuleParser
 5814         {
 5815             public TypeIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5816             {
 5817                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5818                 SetValueTypeName(ToUtf32("Type*"));
 5819             }
 5820             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5821             {
 5822                 parsingData->PushContext(Id(), new Context());
 5823                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5824                 UniquePtr<Object> context_value = stack.Pop();
 5825                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5826             }
 5827             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5828             {
 5829                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5830                 if (matched)
 5831                 {
 5832                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 5833                 }
 5834                 parsingData->PopContext(Id());
 5835             }
 5836             public override void Link()
 5837             {
 5838                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5839                 a0ActionParser->SetAction(A0Action);
 5840                 NonterminalParser* uintNonterminalParser = GetNonterminal(ToUtf32("uint"));
 5841                 uintNonterminalParser->SetPost(Postuint);
 5842             }
 5843             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5844             {
 5845                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5846                 context->value = context->context->GetTypeById(span.lineNumber, ToUtf8(ustring(matchBegin, matchEnd)));
 5847             }
 5848             public void Postuint(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5849             {
 5850                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5851                 if (matched)
 5852                 {
 5853                     UniquePtr<Object> fromuint_value = stack.Pop();
 5854                     context->fromuint = *cast<ValueObject<uint>*>(fromuint_value.Get());
 5855                 }
 5856             }
 5857             public class Context : System.Text.Parsing.Context
 5858             {
 5859                 public Context() : context(), value(), fromuint()
 5860                 {
 5861                 }
 5862                 public cmsx.intermediate.Context* context;
 5863                 public Type* value;
 5864                 public uint fromuint;
 5865             }
 5866         }
 5867 
 5868         public class PrimitiveTypeRule : System.Text.Parsing.RuleParser
 5869         {
 5870             public PrimitiveTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5871             {
 5872                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5873                 SetValueTypeName(ToUtf32("Type*"));
 5874             }
 5875             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5876             {
 5877                 parsingData->PushContext(Id(), new Context());
 5878                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5879                 UniquePtr<Object> context_value = stack.Pop();
 5880                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5881             }
 5882             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5883             {
 5884                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5885                 if (matched)
 5886                 {
 5887                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 5888                 }
 5889                 parsingData->PopContext(Id());
 5890             }
 5891             public override void Link()
 5892             {
 5893                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5894                 a0ActionParser->SetAction(A0Action);
 5895                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 5896                 a1ActionParser->SetAction(A1Action);
 5897                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 5898                 a2ActionParser->SetAction(A2Action);
 5899                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 5900                 a3ActionParser->SetAction(A3Action);
 5901                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
 5902                 a4ActionParser->SetAction(A4Action);
 5903                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
 5904                 a5ActionParser->SetAction(A5Action);
 5905                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
 5906                 a6ActionParser->SetAction(A6Action);
 5907                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
 5908                 a7ActionParser->SetAction(A7Action);
 5909                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
 5910                 a8ActionParser->SetAction(A8Action);
 5911                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
 5912                 a9ActionParser->SetAction(A9Action);
 5913                 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
 5914                 a10ActionParser->SetAction(A10Action);
 5915                 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
 5916                 a11ActionParser->SetAction(A11Action);
 5917                 NonterminalParser* voidTypeNonterminalParser = GetNonterminal(ToUtf32("VoidType"));
 5918                 voidTypeNonterminalParser->SetPre(PreVoidType);
 5919                 voidTypeNonterminalParser->SetPost(PostVoidType);
 5920                 NonterminalParser* boolTypeNonterminalParser = GetNonterminal(ToUtf32("BoolType"));
 5921                 boolTypeNonterminalParser->SetPre(PreBoolType);
 5922                 boolTypeNonterminalParser->SetPost(PostBoolType);
 5923                 NonterminalParser* sByteTypeNonterminalParser = GetNonterminal(ToUtf32("SByteType"));
 5924                 sByteTypeNonterminalParser->SetPre(PreSByteType);
 5925                 sByteTypeNonterminalParser->SetPost(PostSByteType);
 5926                 NonterminalParser* byteTypeNonterminalParser = GetNonterminal(ToUtf32("ByteType"));
 5927                 byteTypeNonterminalParser->SetPre(PreByteType);
 5928                 byteTypeNonterminalParser->SetPost(PostByteType);
 5929                 NonterminalParser* shortTypeNonterminalParser = GetNonterminal(ToUtf32("ShortType"));
 5930                 shortTypeNonterminalParser->SetPre(PreShortType);
 5931                 shortTypeNonterminalParser->SetPost(PostShortType);
 5932                 NonterminalParser* uShortTypeNonterminalParser = GetNonterminal(ToUtf32("UShortType"));
 5933                 uShortTypeNonterminalParser->SetPre(PreUShortType);
 5934                 uShortTypeNonterminalParser->SetPost(PostUShortType);
 5935                 NonterminalParser* intTypeNonterminalParser = GetNonterminal(ToUtf32("IntType"));
 5936                 intTypeNonterminalParser->SetPre(PreIntType);
 5937                 intTypeNonterminalParser->SetPost(PostIntType);
 5938                 NonterminalParser* uIntTypeNonterminalParser = GetNonterminal(ToUtf32("UIntType"));
 5939                 uIntTypeNonterminalParser->SetPre(PreUIntType);
 5940                 uIntTypeNonterminalParser->SetPost(PostUIntType);
 5941                 NonterminalParser* longTypeNonterminalParser = GetNonterminal(ToUtf32("LongType"));
 5942                 longTypeNonterminalParser->SetPre(PreLongType);
 5943                 longTypeNonterminalParser->SetPost(PostLongType);
 5944                 NonterminalParser* uLongTypeNonterminalParser = GetNonterminal(ToUtf32("ULongType"));
 5945                 uLongTypeNonterminalParser->SetPre(PreULongType);
 5946                 uLongTypeNonterminalParser->SetPost(PostULongType);
 5947                 NonterminalParser* floatTypeNonterminalParser = GetNonterminal(ToUtf32("FloatType"));
 5948                 floatTypeNonterminalParser->SetPre(PreFloatType);
 5949                 floatTypeNonterminalParser->SetPost(PostFloatType);
 5950                 NonterminalParser* doubleTypeNonterminalParser = GetNonterminal(ToUtf32("DoubleType"));
 5951                 doubleTypeNonterminalParser->SetPre(PreDoubleType);
 5952                 doubleTypeNonterminalParser->SetPost(PostDoubleType);
 5953             }
 5954             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5955             {
 5956                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5957                 context->value = context->fromVoidType;
 5958             }
 5959             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5960             {
 5961                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5962                 context->value = context->fromBoolType;
 5963             }
 5964             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5965             {
 5966                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5967                 context->value = context->fromSByteType;
 5968             }
 5969             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5970             {
 5971                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5972                 context->value = context->fromByteType;
 5973             }
 5974             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5975             {
 5976                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5977                 context->value = context->fromShortType;
 5978             }
 5979             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5980             {
 5981                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5982                 context->value = context->fromUShortType;
 5983             }
 5984             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5985             {
 5986                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5987                 context->value = context->fromIntType;
 5988             }
 5989             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5990             {
 5991                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5992                 context->value = context->fromUIntType;
 5993             }
 5994             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5995             {
 5996                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5997                 context->value = context->fromLongType;
 5998             }
 5999             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6000             {
 6001                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6002                 context->value = context->fromULongType;
 6003             }
 6004             public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6005             {
 6006                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6007                 context->value = context->fromFloatType;
 6008             }
 6009             public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6010             {
 6011                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6012                 context->value = context->fromDoubleType;
 6013             }
 6014             public void PreVoidType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6015             {
 6016                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6017                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6018             }
 6019             public void PostVoidType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6020             {
 6021                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6022                 if (matched)
 6023                 {
 6024                     UniquePtr<Object> fromVoidType_value = stack.Pop();
 6025                     context->fromVoidType = *cast<ValueObject<Type*>*>(fromVoidType_value.Get());
 6026                 }
 6027             }
 6028             public void PreBoolType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6029             {
 6030                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6031                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6032             }
 6033             public void PostBoolType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6034             {
 6035                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6036                 if (matched)
 6037                 {
 6038                     UniquePtr<Object> fromBoolType_value = stack.Pop();
 6039                     context->fromBoolType = *cast<ValueObject<Type*>*>(fromBoolType_value.Get());
 6040                 }
 6041             }
 6042             public void PreSByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6043             {
 6044                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6045                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6046             }
 6047             public void PostSByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6048             {
 6049                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6050                 if (matched)
 6051                 {
 6052                     UniquePtr<Object> fromSByteType_value = stack.Pop();
 6053                     context->fromSByteType = *cast<ValueObject<Type*>*>(fromSByteType_value.Get());
 6054                 }
 6055             }
 6056             public void PreByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6057             {
 6058                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6059                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6060             }
 6061             public void PostByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6062             {
 6063                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6064                 if (matched)
 6065                 {
 6066                     UniquePtr<Object> fromByteType_value = stack.Pop();
 6067                     context->fromByteType = *cast<ValueObject<Type*>*>(fromByteType_value.Get());
 6068                 }
 6069             }
 6070             public void PreShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6071             {
 6072                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6073                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6074             }
 6075             public void PostShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6076             {
 6077                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6078                 if (matched)
 6079                 {
 6080                     UniquePtr<Object> fromShortType_value = stack.Pop();
 6081                     context->fromShortType = *cast<ValueObject<Type*>*>(fromShortType_value.Get());
 6082                 }
 6083             }
 6084             public void PreUShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6085             {
 6086                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6087                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6088             }
 6089             public void PostUShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6090             {
 6091                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6092                 if (matched)
 6093                 {
 6094                     UniquePtr<Object> fromUShortType_value = stack.Pop();
 6095                     context->fromUShortType = *cast<ValueObject<Type*>*>(fromUShortType_value.Get());
 6096                 }
 6097             }
 6098             public void PreIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6099             {
 6100                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6101                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6102             }
 6103             public void PostIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6104             {
 6105                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6106                 if (matched)
 6107                 {
 6108                     UniquePtr<Object> fromIntType_value = stack.Pop();
 6109                     context->fromIntType = *cast<ValueObject<Type*>*>(fromIntType_value.Get());
 6110                 }
 6111             }
 6112             public void PreUIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6113             {
 6114                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6115                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6116             }
 6117             public void PostUIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6118             {
 6119                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6120                 if (matched)
 6121                 {
 6122                     UniquePtr<Object> fromUIntType_value = stack.Pop();
 6123                     context->fromUIntType = *cast<ValueObject<Type*>*>(fromUIntType_value.Get());
 6124                 }
 6125             }
 6126             public void PreLongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6127             {
 6128                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6129                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6130             }
 6131             public void PostLongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6132             {
 6133                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6134                 if (matched)
 6135                 {
 6136                     UniquePtr<Object> fromLongType_value = stack.Pop();
 6137                     context->fromLongType = *cast<ValueObject<Type*>*>(fromLongType_value.Get());
 6138                 }
 6139             }
 6140             public void PreULongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6141             {
 6142                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6143                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6144             }
 6145             public void PostULongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6146             {
 6147                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6148                 if (matched)
 6149                 {
 6150                     UniquePtr<Object> fromULongType_value = stack.Pop();
 6151                     context->fromULongType = *cast<ValueObject<Type*>*>(fromULongType_value.Get());
 6152                 }
 6153             }
 6154             public void PreFloatType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6155             {
 6156                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6157                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6158             }
 6159             public void PostFloatType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6160             {
 6161                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6162                 if (matched)
 6163                 {
 6164                     UniquePtr<Object> fromFloatType_value = stack.Pop();
 6165                     context->fromFloatType = *cast<ValueObject<Type*>*>(fromFloatType_value.Get());
 6166                 }
 6167             }
 6168             public void PreDoubleType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6169             {
 6170                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6171                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6172             }
 6173             public void PostDoubleType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6174             {
 6175                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6176                 if (matched)
 6177                 {
 6178                     UniquePtr<Object> fromDoubleType_value = stack.Pop();
 6179                     context->fromDoubleType = *cast<ValueObject<Type*>*>(fromDoubleType_value.Get());
 6180                 }
 6181             }
 6182             public class Context : System.Text.Parsing.Context
 6183             {
 6184                 public Context() : context(), value(), fromVoidType(), fromBoolType(), fromSByteType(), fromByteType(), fromShortType(), fromUShortType(), fromIntType(), fromUIntType(), fromLongType(), fromULongType(), fromFloatType(), fromDoubleType()
 6185                 {
 6186                 }
 6187                 public cmsx.intermediate.Context* context;
 6188                 public Type* value;
 6189                 public Type* fromVoidType;
 6190                 public Type* fromBoolType;
 6191                 public Type* fromSByteType;
 6192                 public Type* fromByteType;
 6193                 public Type* fromShortType;
 6194                 public Type* fromUShortType;
 6195                 public Type* fromIntType;
 6196                 public Type* fromUIntType;
 6197                 public Type* fromLongType;
 6198                 public Type* fromULongType;
 6199                 public Type* fromFloatType;
 6200                 public Type* fromDoubleType;
 6201             }
 6202         }
 6203 
 6204         public class VoidTypeRule : System.Text.Parsing.RuleParser
 6205         {
 6206             public VoidTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6207             {
 6208                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6209                 SetValueTypeName(ToUtf32("Type*"));
 6210             }
 6211             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6212             {
 6213                 parsingData->PushContext(Id(), new Context());
 6214                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6215                 UniquePtr<Object> context_value = stack.Pop();
 6216                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6217             }
 6218             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6219             {
 6220                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6221                 if (matched)
 6222                 {
 6223                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6224                 }
 6225                 parsingData->PopContext(Id());
 6226             }
 6227             public override void Link()
 6228             {
 6229                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6230                 a0ActionParser->SetAction(A0Action);
 6231             }
 6232             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6233             {
 6234                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6235                 context->value = context->context->GetVoidType();
 6236             }
 6237             public class Context : System.Text.Parsing.Context
 6238             {
 6239                 public Context() : context(), value()
 6240                 {
 6241                 }
 6242                 public cmsx.intermediate.Context* context;
 6243                 public Type* value;
 6244             }
 6245         }
 6246 
 6247         public class BoolTypeRule : System.Text.Parsing.RuleParser
 6248         {
 6249             public BoolTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6250             {
 6251                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6252                 SetValueTypeName(ToUtf32("Type*"));
 6253             }
 6254             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6255             {
 6256                 parsingData->PushContext(Id(), new Context());
 6257                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6258                 UniquePtr<Object> context_value = stack.Pop();
 6259                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6260             }
 6261             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6262             {
 6263                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6264                 if (matched)
 6265                 {
 6266                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6267                 }
 6268                 parsingData->PopContext(Id());
 6269             }
 6270             public override void Link()
 6271             {
 6272                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6273                 a0ActionParser->SetAction(A0Action);
 6274             }
 6275             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6276             {
 6277                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6278                 context->value = context->context->GetBoolType();
 6279             }
 6280             public class Context : System.Text.Parsing.Context
 6281             {
 6282                 public Context() : context(), value()
 6283                 {
 6284                 }
 6285                 public cmsx.intermediate.Context* context;
 6286                 public Type* value;
 6287             }
 6288         }
 6289 
 6290         public class SByteTypeRule : System.Text.Parsing.RuleParser
 6291         {
 6292             public SByteTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6293             {
 6294                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6295                 SetValueTypeName(ToUtf32("Type*"));
 6296             }
 6297             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6298             {
 6299                 parsingData->PushContext(Id(), new Context());
 6300                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6301                 UniquePtr<Object> context_value = stack.Pop();
 6302                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6303             }
 6304             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6305             {
 6306                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6307                 if (matched)
 6308                 {
 6309                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6310                 }
 6311                 parsingData->PopContext(Id());
 6312             }
 6313             public override void Link()
 6314             {
 6315                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6316                 a0ActionParser->SetAction(A0Action);
 6317             }
 6318             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6319             {
 6320                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6321                 context->value = context->context->GetSByteType();
 6322             }
 6323             public class Context : System.Text.Parsing.Context
 6324             {
 6325                 public Context() : context(), value()
 6326                 {
 6327                 }
 6328                 public cmsx.intermediate.Context* context;
 6329                 public Type* value;
 6330             }
 6331         }
 6332 
 6333         public class ByteTypeRule : System.Text.Parsing.RuleParser
 6334         {
 6335             public ByteTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6336             {
 6337                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6338                 SetValueTypeName(ToUtf32("Type*"));
 6339             }
 6340             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6341             {
 6342                 parsingData->PushContext(Id(), new Context());
 6343                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6344                 UniquePtr<Object> context_value = stack.Pop();
 6345                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6346             }
 6347             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6348             {
 6349                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6350                 if (matched)
 6351                 {
 6352                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6353                 }
 6354                 parsingData->PopContext(Id());
 6355             }
 6356             public override void Link()
 6357             {
 6358                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6359                 a0ActionParser->SetAction(A0Action);
 6360             }
 6361             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6362             {
 6363                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6364                 context->value = context->context->GetByteType();
 6365             }
 6366             public class Context : System.Text.Parsing.Context
 6367             {
 6368                 public Context() : context(), value()
 6369                 {
 6370                 }
 6371                 public cmsx.intermediate.Context* context;
 6372                 public Type* value;
 6373             }
 6374         }
 6375 
 6376         public class ShortTypeRule : System.Text.Parsing.RuleParser
 6377         {
 6378             public ShortTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6379             {
 6380                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6381                 SetValueTypeName(ToUtf32("Type*"));
 6382             }
 6383             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6384             {
 6385                 parsingData->PushContext(Id(), new Context());
 6386                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6387                 UniquePtr<Object> context_value = stack.Pop();
 6388                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6389             }
 6390             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6391             {
 6392                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6393                 if (matched)
 6394                 {
 6395                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6396                 }
 6397                 parsingData->PopContext(Id());
 6398             }
 6399             public override void Link()
 6400             {
 6401                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6402                 a0ActionParser->SetAction(A0Action);
 6403             }
 6404             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6405             {
 6406                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6407                 context->value = context->context->GetShortType();
 6408             }
 6409             public class Context : System.Text.Parsing.Context
 6410             {
 6411                 public Context() : context(), value()
 6412                 {
 6413                 }
 6414                 public cmsx.intermediate.Context* context;
 6415                 public Type* value;
 6416             }
 6417         }
 6418 
 6419         public class UShortTypeRule : System.Text.Parsing.RuleParser
 6420         {
 6421             public UShortTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6422             {
 6423                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6424                 SetValueTypeName(ToUtf32("Type*"));
 6425             }
 6426             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6427             {
 6428                 parsingData->PushContext(Id(), new Context());
 6429                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6430                 UniquePtr<Object> context_value = stack.Pop();
 6431                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6432             }
 6433             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6434             {
 6435                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6436                 if (matched)
 6437                 {
 6438                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6439                 }
 6440                 parsingData->PopContext(Id());
 6441             }
 6442             public override void Link()
 6443             {
 6444                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6445                 a0ActionParser->SetAction(A0Action);
 6446             }
 6447             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6448             {
 6449                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6450                 context->value = context->context->GetUShortType();
 6451             }
 6452             public class Context : System.Text.Parsing.Context
 6453             {
 6454                 public Context() : context(), value()
 6455                 {
 6456                 }
 6457                 public cmsx.intermediate.Context* context;
 6458                 public Type* value;
 6459             }
 6460         }
 6461 
 6462         public class IntTypeRule : System.Text.Parsing.RuleParser
 6463         {
 6464             public IntTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6465             {
 6466                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6467                 SetValueTypeName(ToUtf32("Type*"));
 6468             }
 6469             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6470             {
 6471                 parsingData->PushContext(Id(), new Context());
 6472                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6473                 UniquePtr<Object> context_value = stack.Pop();
 6474                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6475             }
 6476             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6477             {
 6478                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6479                 if (matched)
 6480                 {
 6481                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6482                 }
 6483                 parsingData->PopContext(Id());
 6484             }
 6485             public override void Link()
 6486             {
 6487                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6488                 a0ActionParser->SetAction(A0Action);
 6489             }
 6490             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6491             {
 6492                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6493                 context->value = context->context->GetIntType();
 6494             }
 6495             public class Context : System.Text.Parsing.Context
 6496             {
 6497                 public Context() : context(), value()
 6498                 {
 6499                 }
 6500                 public cmsx.intermediate.Context* context;
 6501                 public Type* value;
 6502             }
 6503         }
 6504 
 6505         public class UIntTypeRule : System.Text.Parsing.RuleParser
 6506         {
 6507             public UIntTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6508             {
 6509                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6510                 SetValueTypeName(ToUtf32("Type*"));
 6511             }
 6512             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6513             {
 6514                 parsingData->PushContext(Id(), new Context());
 6515                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6516                 UniquePtr<Object> context_value = stack.Pop();
 6517                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6518             }
 6519             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6520             {
 6521                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6522                 if (matched)
 6523                 {
 6524                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6525                 }
 6526                 parsingData->PopContext(Id());
 6527             }
 6528             public override void Link()
 6529             {
 6530                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6531                 a0ActionParser->SetAction(A0Action);
 6532             }
 6533             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6534             {
 6535                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6536                 context->value = context->context->GetUIntType();
 6537             }
 6538             public class Context : System.Text.Parsing.Context
 6539             {
 6540                 public Context() : context(), value()
 6541                 {
 6542                 }
 6543                 public cmsx.intermediate.Context* context;
 6544                 public Type* value;
 6545             }
 6546         }
 6547 
 6548         public class LongTypeRule : System.Text.Parsing.RuleParser
 6549         {
 6550             public LongTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6551             {
 6552                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6553                 SetValueTypeName(ToUtf32("Type*"));
 6554             }
 6555             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6556             {
 6557                 parsingData->PushContext(Id(), new Context());
 6558                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6559                 UniquePtr<Object> context_value = stack.Pop();
 6560                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6561             }
 6562             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6563             {
 6564                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6565                 if (matched)
 6566                 {
 6567                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6568                 }
 6569                 parsingData->PopContext(Id());
 6570             }
 6571             public override void Link()
 6572             {
 6573                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6574                 a0ActionParser->SetAction(A0Action);
 6575             }
 6576             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6577             {
 6578                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6579                 context->value = context->context->GetLongType();
 6580             }
 6581             public class Context : System.Text.Parsing.Context
 6582             {
 6583                 public Context() : context(), value()
 6584                 {
 6585                 }
 6586                 public cmsx.intermediate.Context* context;
 6587                 public Type* value;
 6588             }
 6589         }
 6590 
 6591         public class ULongTypeRule : System.Text.Parsing.RuleParser
 6592         {
 6593             public ULongTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6594             {
 6595                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6596                 SetValueTypeName(ToUtf32("Type*"));
 6597             }
 6598             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6599             {
 6600                 parsingData->PushContext(Id(), new Context());
 6601                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6602                 UniquePtr<Object> context_value = stack.Pop();
 6603                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6604             }
 6605             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6606             {
 6607                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6608                 if (matched)
 6609                 {
 6610                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6611                 }
 6612                 parsingData->PopContext(Id());
 6613             }
 6614             public override void Link()
 6615             {
 6616                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6617                 a0ActionParser->SetAction(A0Action);
 6618             }
 6619             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6620             {
 6621                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6622                 context->value = context->context->GetULongType();
 6623             }
 6624             public class Context : System.Text.Parsing.Context
 6625             {
 6626                 public Context() : context(), value()
 6627                 {
 6628                 }
 6629                 public cmsx.intermediate.Context* context;
 6630                 public Type* value;
 6631             }
 6632         }
 6633 
 6634         public class FloatTypeRule : System.Text.Parsing.RuleParser
 6635         {
 6636             public FloatTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6637             {
 6638                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6639                 SetValueTypeName(ToUtf32("Type*"));
 6640             }
 6641             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6642             {
 6643                 parsingData->PushContext(Id(), new Context());
 6644                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6645                 UniquePtr<Object> context_value = stack.Pop();
 6646                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6647             }
 6648             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6649             {
 6650                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6651                 if (matched)
 6652                 {
 6653                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6654                 }
 6655                 parsingData->PopContext(Id());
 6656             }
 6657             public override void Link()
 6658             {
 6659                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6660                 a0ActionParser->SetAction(A0Action);
 6661             }
 6662             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6663             {
 6664                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6665                 context->value = context->context->GetFloatType();
 6666             }
 6667             public class Context : System.Text.Parsing.Context
 6668             {
 6669                 public Context() : context(), value()
 6670                 {
 6671                 }
 6672                 public cmsx.intermediate.Context* context;
 6673                 public Type* value;
 6674             }
 6675         }
 6676 
 6677         public class DoubleTypeRule : System.Text.Parsing.RuleParser
 6678         {
 6679             public DoubleTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6680             {
 6681                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6682                 SetValueTypeName(ToUtf32("Type*"));
 6683             }
 6684             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6685             {
 6686                 parsingData->PushContext(Id(), new Context());
 6687                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6688                 UniquePtr<Object> context_value = stack.Pop();
 6689                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6690             }
 6691             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6692             {
 6693                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6694                 if (matched)
 6695                 {
 6696                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6697                 }
 6698                 parsingData->PopContext(Id());
 6699             }
 6700             public override void Link()
 6701             {
 6702                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6703                 a0ActionParser->SetAction(A0Action);
 6704             }
 6705             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6706             {
 6707                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6708                 context->value = context->context->GetDoubleType();
 6709             }
 6710             public class Context : System.Text.Parsing.Context
 6711             {
 6712                 public Context() : context(), value()
 6713                 {
 6714                 }
 6715                 public cmsx.intermediate.Context* context;
 6716                 public Type* value;
 6717             }
 6718         }
 6719 
 6720         public class DataDefinitionRule : System.Text.Parsing.RuleParser
 6721         {
 6722             public DataDefinitionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6723             {
 6724                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6725             }
 6726             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6727             {
 6728                 parsingData->PushContext(Id(), new Context());
 6729                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6730                 UniquePtr<Object> context_value = stack.Pop();
 6731                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6732             }
 6733             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6734             {
 6735                 parsingData->PopContext(Id());
 6736             }
 6737             public override void Link()
 6738             {
 6739                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6740                 a0ActionParser->SetAction(A0Action);
 6741                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 6742                 a1ActionParser->SetAction(A1Action);
 6743                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 6744                 typeNonterminalParser->SetPre(Pretype);
 6745                 typeNonterminalParser->SetPost(Posttype);
 6746                 NonterminalParser* nameNonterminalParser = GetNonterminal(ToUtf32("name"));
 6747                 nameNonterminalParser->SetPost(Postname);
 6748                 NonterminalParser* constantNonterminalParser = GetNonterminal(ToUtf32("Constant"));
 6749                 constantNonterminalParser->SetPre(PreConstant);
 6750                 constantNonterminalParser->SetPost(PostConstant);
 6751             }
 6752             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6753             {
 6754                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6755                 context->context->AddDataDefinition(context->fromtype, ToUtf8(context->fromname), cast<ConstantValue*>(null));
 6756             }
 6757             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6758             {
 6759                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6760                 context->context->AddDataDefinition(context->fromtype, ToUtf8(context->fromname), context->fromConstant);
 6761             }
 6762             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6763             {
 6764                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6765                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6766             }
 6767             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6768             {
 6769                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6770                 if (matched)
 6771                 {
 6772                     UniquePtr<Object> fromtype_value = stack.Pop();
 6773                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 6774                 }
 6775             }
 6776             public void Postname(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6777             {
 6778                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6779                 if (matched)
 6780                 {
 6781                     UniquePtr<Object> fromname_value = stack.Pop();
 6782                     context->fromname = *cast<ValueObject<ustring>*>(fromname_value.Get());
 6783                 }
 6784             }
 6785             public void PreConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6786             {
 6787                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6788                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6789             }
 6790             public void PostConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6791             {
 6792                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6793                 if (matched)
 6794                 {
 6795                     UniquePtr<Object> fromConstant_value = stack.Pop();
 6796                     context->fromConstant = *cast<ValueObject<ConstantValue*>*>(fromConstant_value.Get());
 6797                 }
 6798             }
 6799             public class Context : System.Text.Parsing.Context
 6800             {
 6801                 public Context() : context(), fromtype(), fromname(), fromConstant()
 6802                 {
 6803                 }
 6804                 public cmsx.intermediate.Context* context;
 6805                 public Type* fromtype;
 6806                 public ustring fromname;
 6807                 public ConstantValue* fromConstant;
 6808             }
 6809         }
 6810 
 6811         public class ConstantRule : System.Text.Parsing.RuleParser
 6812         {
 6813             public ConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6814             {
 6815                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6816                 SetValueTypeName(ToUtf32("ConstantValue*"));
 6817             }
 6818             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6819             {
 6820                 parsingData->PushContext(Id(), new Context());
 6821                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6822                 UniquePtr<Object> context_value = stack.Pop();
 6823                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6824             }
 6825             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6826             {
 6827                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6828                 if (matched)
 6829                 {
 6830                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 6831                 }
 6832                 parsingData->PopContext(Id());
 6833             }
 6834             public override void Link()
 6835             {
 6836                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6837                 a0ActionParser->SetAction(A0Action);
 6838                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 6839                 a1ActionParser->SetAction(A1Action);
 6840                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 6841                 a2ActionParser->SetAction(A2Action);
 6842                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 6843                 a3ActionParser->SetAction(A3Action);
 6844                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
 6845                 a4ActionParser->SetAction(A4Action);
 6846                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
 6847                 a5ActionParser->SetAction(A5Action);
 6848                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
 6849                 a6ActionParser->SetAction(A6Action);
 6850                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
 6851                 a7ActionParser->SetAction(A7Action);
 6852                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
 6853                 a8ActionParser->SetAction(A8Action);
 6854                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
 6855                 a9ActionParser->SetAction(A9Action);
 6856                 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
 6857                 a10ActionParser->SetAction(A10Action);
 6858                 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
 6859                 a11ActionParser->SetAction(A11Action);
 6860                 ActionParser* a12ActionParser = GetAction(ToUtf32("A12"));
 6861                 a12ActionParser->SetAction(A12Action);
 6862                 ActionParser* a13ActionParser = GetAction(ToUtf32("A13"));
 6863                 a13ActionParser->SetAction(A13Action);
 6864                 NonterminalParser* boolConstantNonterminalParser = GetNonterminal(ToUtf32("BoolConstant"));
 6865                 boolConstantNonterminalParser->SetPre(PreBoolConstant);
 6866                 boolConstantNonterminalParser->SetPost(PostBoolConstant);
 6867                 NonterminalParser* sByteConstantNonterminalParser = GetNonterminal(ToUtf32("SByteConstant"));
 6868                 sByteConstantNonterminalParser->SetPre(PreSByteConstant);
 6869                 sByteConstantNonterminalParser->SetPost(PostSByteConstant);
 6870                 NonterminalParser* byteConstantNonterminalParser = GetNonterminal(ToUtf32("ByteConstant"));
 6871                 byteConstantNonterminalParser->SetPre(PreByteConstant);
 6872                 byteConstantNonterminalParser->SetPost(PostByteConstant);
 6873                 NonterminalParser* shortConstantNonterminalParser = GetNonterminal(ToUtf32("ShortConstant"));
 6874                 shortConstantNonterminalParser->SetPre(PreShortConstant);
 6875                 shortConstantNonterminalParser->SetPost(PostShortConstant);
 6876                 NonterminalParser* uShortConstantNonterminalParser = GetNonterminal(ToUtf32("UShortConstant"));
 6877                 uShortConstantNonterminalParser->SetPre(PreUShortConstant);
 6878                 uShortConstantNonterminalParser->SetPost(PostUShortConstant);
 6879                 NonterminalParser* intConstantNonterminalParser = GetNonterminal(ToUtf32("IntConstant"));
 6880                 intConstantNonterminalParser->SetPre(PreIntConstant);
 6881                 intConstantNonterminalParser->SetPost(PostIntConstant);
 6882                 NonterminalParser* uIntConstantNonterminalParser = GetNonterminal(ToUtf32("UIntConstant"));
 6883                 uIntConstantNonterminalParser->SetPre(PreUIntConstant);
 6884                 uIntConstantNonterminalParser->SetPost(PostUIntConstant);
 6885                 NonterminalParser* longConstantNonterminalParser = GetNonterminal(ToUtf32("LongConstant"));
 6886                 longConstantNonterminalParser->SetPre(PreLongConstant);
 6887                 longConstantNonterminalParser->SetPost(PostLongConstant);
 6888                 NonterminalParser* uLongConstantNonterminalParser = GetNonterminal(ToUtf32("ULongConstant"));
 6889                 uLongConstantNonterminalParser->SetPre(PreULongConstant);
 6890                 uLongConstantNonterminalParser->SetPost(PostULongConstant);
 6891                 NonterminalParser* floatConstantNonterminalParser = GetNonterminal(ToUtf32("FloatConstant"));
 6892                 floatConstantNonterminalParser->SetPre(PreFloatConstant);
 6893                 floatConstantNonterminalParser->SetPost(PostFloatConstant);
 6894                 NonterminalParser* doubleConstantNonterminalParser = GetNonterminal(ToUtf32("DoubleConstant"));
 6895                 doubleConstantNonterminalParser->SetPre(PreDoubleConstant);
 6896                 doubleConstantNonterminalParser->SetPost(PostDoubleConstant);
 6897                 NonterminalParser* ptrConstantNonterminalParser = GetNonterminal(ToUtf32("PtrConstant"));
 6898                 ptrConstantNonterminalParser->SetPre(PrePtrConstant);
 6899                 ptrConstantNonterminalParser->SetPost(PostPtrConstant);
 6900                 NonterminalParser* arrayConstantNonterminalParser = GetNonterminal(ToUtf32("ArrayConstant"));
 6901                 arrayConstantNonterminalParser->SetPre(PreArrayConstant);
 6902                 arrayConstantNonterminalParser->SetPost(PostArrayConstant);
 6903                 NonterminalParser* structureConstantNonterminalParser = GetNonterminal(ToUtf32("StructureConstant"));
 6904                 structureConstantNonterminalParser->SetPre(PreStructureConstant);
 6905                 structureConstantNonterminalParser->SetPost(PostStructureConstant);
 6906             }
 6907             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6908             {
 6909                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6910                 context->value = context->fromBoolConstant;
 6911             }
 6912             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6913             {
 6914                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6915                 context->value = context->fromSByteConstant;
 6916             }
 6917             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6918             {
 6919                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6920                 context->value = context->fromByteConstant;
 6921             }
 6922             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6923             {
 6924                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6925                 context->value = context->fromShortConstant;
 6926             }
 6927             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6928             {
 6929                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6930                 context->value = context->fromUShortConstant;
 6931             }
 6932             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6933             {
 6934                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6935                 context->value = context->fromIntConstant;
 6936             }
 6937             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6938             {
 6939                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6940                 context->value = context->fromUIntConstant;
 6941             }
 6942             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6943             {
 6944                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6945                 context->value = context->fromLongConstant;
 6946             }
 6947             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6948             {
 6949                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6950                 context->value = context->fromULongConstant;
 6951             }
 6952             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6953             {
 6954                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6955                 context->value = context->fromFloatConstant;
 6956             }
 6957             public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6958             {
 6959                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6960                 context->value = context->fromDoubleConstant;
 6961             }
 6962             public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6963             {
 6964                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6965                 context->value = context->fromPtrConstant;
 6966             }
 6967             public void A12Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6968             {
 6969                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6970                 context->value = context->fromArrayConstant;
 6971             }
 6972             public void A13Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6973             {
 6974                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6975                 context->value = context->fromStructureConstant;
 6976             }
 6977             public void PreBoolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6978             {
 6979                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6980                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6981             }
 6982             public void PostBoolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6983             {
 6984                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6985                 if (matched)
 6986                 {
 6987                     UniquePtr<Object> fromBoolConstant_value = stack.Pop();
 6988                     context->fromBoolConstant = *cast<ValueObject<ConstantValue*>*>(fromBoolConstant_value.Get());
 6989                 }
 6990             }
 6991             public void PreSByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6992             {
 6993                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6994                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6995             }
 6996             public void PostSByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6997             {
 6998                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6999                 if (matched)
 7000                 {
 7001                     UniquePtr<Object> fromSByteConstant_value = stack.Pop();
 7002                     context->fromSByteConstant = *cast<ValueObject<ConstantValue*>*>(fromSByteConstant_value.Get());
 7003                 }
 7004             }
 7005             public void PreByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7006             {
 7007                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7008                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7009             }
 7010             public void PostByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7011             {
 7012                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7013                 if (matched)
 7014                 {
 7015                     UniquePtr<Object> fromByteConstant_value = stack.Pop();
 7016                     context->fromByteConstant = *cast<ValueObject<ConstantValue*>*>(fromByteConstant_value.Get());
 7017                 }
 7018             }
 7019             public void PreShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7020             {
 7021                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7022                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7023             }
 7024             public void PostShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7025             {
 7026                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7027                 if (matched)
 7028                 {
 7029                     UniquePtr<Object> fromShortConstant_value = stack.Pop();
 7030                     context->fromShortConstant = *cast<ValueObject<ConstantValue*>*>(fromShortConstant_value.Get());
 7031                 }
 7032             }
 7033             public void PreUShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7034             {
 7035                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7036                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7037             }
 7038             public void PostUShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7039             {
 7040                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7041                 if (matched)
 7042                 {
 7043                     UniquePtr<Object> fromUShortConstant_value = stack.Pop();
 7044                     context->fromUShortConstant = *cast<ValueObject<ConstantValue*>*>(fromUShortConstant_value.Get());
 7045                 }
 7046             }
 7047             public void PreIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7048             {
 7049                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7050                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7051             }
 7052             public void PostIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7053             {
 7054                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7055                 if (matched)
 7056                 {
 7057                     UniquePtr<Object> fromIntConstant_value = stack.Pop();
 7058                     context->fromIntConstant = *cast<ValueObject<ConstantValue*>*>(fromIntConstant_value.Get());
 7059                 }
 7060             }
 7061             public void PreUIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7062             {
 7063                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7064                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7065             }
 7066             public void PostUIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7067             {
 7068                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7069                 if (matched)
 7070                 {
 7071                     UniquePtr<Object> fromUIntConstant_value = stack.Pop();
 7072                     context->fromUIntConstant = *cast<ValueObject<ConstantValue*>*>(fromUIntConstant_value.Get());
 7073                 }
 7074             }
 7075             public void PreLongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7076             {
 7077                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7078                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7079             }
 7080             public void PostLongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7081             {
 7082                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7083                 if (matched)
 7084                 {
 7085                     UniquePtr<Object> fromLongConstant_value = stack.Pop();
 7086                     context->fromLongConstant = *cast<ValueObject<ConstantValue*>*>(fromLongConstant_value.Get());
 7087                 }
 7088             }
 7089             public void PreULongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7090             {
 7091                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7092                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7093             }
 7094             public void PostULongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7095             {
 7096                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7097                 if (matched)
 7098                 {
 7099                     UniquePtr<Object> fromULongConstant_value = stack.Pop();
 7100                     context->fromULongConstant = *cast<ValueObject<ConstantValue*>*>(fromULongConstant_value.Get());
 7101                 }
 7102             }
 7103             public void PreFloatConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7104             {
 7105                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7106                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7107             }
 7108             public void PostFloatConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7109             {
 7110                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7111                 if (matched)
 7112                 {
 7113                     UniquePtr<Object> fromFloatConstant_value = stack.Pop();
 7114                     context->fromFloatConstant = *cast<ValueObject<ConstantValue*>*>(fromFloatConstant_value.Get());
 7115                 }
 7116             }
 7117             public void PreDoubleConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7118             {
 7119                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7120                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7121             }
 7122             public void PostDoubleConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7123             {
 7124                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7125                 if (matched)
 7126                 {
 7127                     UniquePtr<Object> fromDoubleConstant_value = stack.Pop();
 7128                     context->fromDoubleConstant = *cast<ValueObject<ConstantValue*>*>(fromDoubleConstant_value.Get());
 7129                 }
 7130             }
 7131             public void PrePtrConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7132             {
 7133                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7134                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7135             }
 7136             public void PostPtrConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7137             {
 7138                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7139                 if (matched)
 7140                 {
 7141                     UniquePtr<Object> fromPtrConstant_value = stack.Pop();
 7142                     context->fromPtrConstant = *cast<ValueObject<ConstantValue*>*>(fromPtrConstant_value.Get());
 7143                 }
 7144             }
 7145             public void PreArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7146             {
 7147                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7148                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7149             }
 7150             public void PostArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7151             {
 7152                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7153                 if (matched)
 7154                 {
 7155                     UniquePtr<Object> fromArrayConstant_value = stack.Pop();
 7156                     context->fromArrayConstant = *cast<ValueObject<ArrayValue*>*>(fromArrayConstant_value.Get());
 7157                 }
 7158             }
 7159             public void PreStructureConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7160             {
 7161                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7162                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7163             }
 7164             public void PostStructureConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7165             {
 7166                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7167                 if (matched)
 7168                 {
 7169                     UniquePtr<Object> fromStructureConstant_value = stack.Pop();
 7170                     context->fromStructureConstant = *cast<ValueObject<StructureValue*>*>(fromStructureConstant_value.Get());
 7171                 }
 7172             }
 7173             public class Context : System.Text.Parsing.Context
 7174             {
 7175                 public Context() : context(), value(), fromBoolConstant(), fromSByteConstant(), fromByteConstant(), fromShortConstant(), fromUShortConstant(), fromIntConstant(), fromUIntConstant(), fromLongConstant(), fromULongConstant(), fromFloatConstant(), fromDoubleConstant(), fromPtrConstant(), fromArrayConstant(), fromStructureConstant()
 7176                 {
 7177                 }
 7178                 public cmsx.intermediate.Context* context;
 7179                 public ConstantValue* value;
 7180                 public ConstantValue* fromBoolConstant;
 7181                 public ConstantValue* fromSByteConstant;
 7182                 public ConstantValue* fromByteConstant;
 7183                 public ConstantValue* fromShortConstant;
 7184                 public ConstantValue* fromUShortConstant;
 7185                 public ConstantValue* fromIntConstant;
 7186                 public ConstantValue* fromUIntConstant;
 7187                 public ConstantValue* fromLongConstant;
 7188                 public ConstantValue* fromULongConstant;
 7189                 public ConstantValue* fromFloatConstant;
 7190                 public ConstantValue* fromDoubleConstant;
 7191                 public ConstantValue* fromPtrConstant;
 7192                 public ArrayValue* fromArrayConstant;
 7193                 public StructureValue* fromStructureConstant;
 7194             }
 7195         }
 7196 
 7197         public class BoolConstantRule : System.Text.Parsing.RuleParser
 7198         {
 7199             public BoolConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7200             {
 7201                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7202                 SetValueTypeName(ToUtf32("ConstantValue*"));
 7203             }
 7204             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7205             {
 7206                 parsingData->PushContext(Id(), new Context());
 7207                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7208                 UniquePtr<Object> context_value = stack.Pop();
 7209                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7210             }
 7211             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7212             {
 7213                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7214                 if (matched)
 7215                 {
 7216                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 7217                 }
 7218                 parsingData->PopContext(Id());
 7219             }
 7220             public override void Link()
 7221             {
 7222                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7223                 a0ActionParser->SetAction(A0Action);
 7224                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 7225                 typeNonterminalParser->SetPre(Pretype);
 7226                 typeNonterminalParser->SetPost(Posttype);
 7227                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 7228                 valNonterminalParser->SetPost(Postval);
 7229             }
 7230             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7231             {
 7232                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7233                 context->value = cast<BoolType*>(context->fromtype)->MakeBoolValue(context->fromval);
 7234             }
 7235             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7236             {
 7237                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7238                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7239             }
 7240             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7241             {
 7242                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7243                 if (matched)
 7244                 {
 7245                     UniquePtr<Object> fromtype_value = stack.Pop();
 7246                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 7247                 }
 7248             }
 7249             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7250             {
 7251                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7252                 if (matched)
 7253                 {
 7254                     UniquePtr<Object> fromval_value = stack.Pop();
 7255                     context->fromval = *cast<ValueObject<bool>*>(fromval_value.Get());
 7256                 }
 7257             }
 7258             public class Context : System.Text.Parsing.Context
 7259             {
 7260                 public Context() : context(), value(), fromtype(), fromval()
 7261                 {
 7262                 }
 7263                 public cmsx.intermediate.Context* context;
 7264                 public ConstantValue* value;
 7265                 public Type* fromtype;
 7266                 public bool fromval;
 7267             }
 7268         }
 7269 
 7270         public class BoolValueRule : System.Text.Parsing.RuleParser
 7271         {
 7272             public BoolValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7273             {
 7274                 SetValueTypeName(ToUtf32("bool"));
 7275             }
 7276             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7277             {
 7278                 parsingData->PushContext(Id(), new Context());
 7279                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7280             }
 7281             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7282             {
 7283                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7284                 if (matched)
 7285                 {
 7286                     stack.Push(UniquePtr<Object>(new ValueObject<bool>(context->value)));
 7287                 }
 7288                 parsingData->PopContext(Id());
 7289             }
 7290             public override void Link()
 7291             {
 7292                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7293                 a0ActionParser->SetAction(A0Action);
 7294                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 7295                 xNonterminalParser->SetPost(Postx);
 7296             }
 7297             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7298             {
 7299                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7300                 context->value = context->fromx;
 7301             }
 7302             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7303             {
 7304                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7305                 if (matched)
 7306                 {
 7307                     UniquePtr<Object> fromx_value = stack.Pop();
 7308                     context->fromx = *cast<ValueObject<bool>*>(fromx_value.Get());
 7309                 }
 7310             }
 7311             public class Context : System.Text.Parsing.Context
 7312             {
 7313                 public Context() : value(), fromx()
 7314                 {
 7315                 }
 7316                 public bool value;
 7317                 public bool fromx;
 7318             }
 7319         }
 7320 
 7321         public class SByteConstantRule : System.Text.Parsing.RuleParser
 7322         {
 7323             public SByteConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7324             {
 7325                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7326                 SetValueTypeName(ToUtf32("ConstantValue*"));
 7327             }
 7328             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7329             {
 7330                 parsingData->PushContext(Id(), new Context());
 7331                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7332                 UniquePtr<Object> context_value = stack.Pop();
 7333                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7334             }
 7335             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7336             {
 7337                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7338                 if (matched)
 7339                 {
 7340                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 7341                 }
 7342                 parsingData->PopContext(Id());
 7343             }
 7344             public override void Link()
 7345             {
 7346                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7347                 a0ActionParser->SetAction(A0Action);
 7348                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 7349                 typeNonterminalParser->SetPre(Pretype);
 7350                 typeNonterminalParser->SetPost(Posttype);
 7351                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 7352                 valNonterminalParser->SetPost(Postval);
 7353             }
 7354             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7355             {
 7356                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7357                 context->value = context->context->MakeSByteValue(cast<SByteType*>(context->fromtype), context->fromval);
 7358             }
 7359             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7360             {
 7361                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7362                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7363             }
 7364             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7365             {
 7366                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7367                 if (matched)
 7368                 {
 7369                     UniquePtr<Object> fromtype_value = stack.Pop();
 7370                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 7371                 }
 7372             }
 7373             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7374             {
 7375                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7376                 if (matched)
 7377                 {
 7378                     UniquePtr<Object> fromval_value = stack.Pop();
 7379                     context->fromval = *cast<ValueObject<sbyte>*>(fromval_value.Get());
 7380                 }
 7381             }
 7382             public class Context : System.Text.Parsing.Context
 7383             {
 7384                 public Context() : context(), value(), fromtype(), fromval()
 7385                 {
 7386                 }
 7387                 public cmsx.intermediate.Context* context;
 7388                 public ConstantValue* value;
 7389                 public Type* fromtype;
 7390                 public sbyte fromval;
 7391             }
 7392         }
 7393 
 7394         public class SByteValueRule : System.Text.Parsing.RuleParser
 7395         {
 7396             public SByteValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7397             {
 7398                 SetValueTypeName(ToUtf32("sbyte"));
 7399             }
 7400             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7401             {
 7402                 parsingData->PushContext(Id(), new Context());
 7403                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7404             }
 7405             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7406             {
 7407                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7408                 if (matched)
 7409                 {
 7410                     stack.Push(UniquePtr<Object>(new ValueObject<sbyte>(context->value)));
 7411                 }
 7412                 parsingData->PopContext(Id());
 7413             }
 7414             public override void Link()
 7415             {
 7416                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7417                 a0ActionParser->SetAction(A0Action);
 7418                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 7419                 xNonterminalParser->SetPost(Postx);
 7420             }
 7421             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7422             {
 7423                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7424                 context->value = context->fromx;
 7425             }
 7426             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7427             {
 7428                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7429                 if (matched)
 7430                 {
 7431                     UniquePtr<Object> fromx_value = stack.Pop();
 7432                     context->fromx = *cast<ValueObject<sbyte>*>(fromx_value.Get());
 7433                 }
 7434             }
 7435             public class Context : System.Text.Parsing.Context
 7436             {
 7437                 public Context() : value(), fromx()
 7438                 {
 7439                 }
 7440                 public sbyte value;
 7441                 public sbyte fromx;
 7442             }
 7443         }
 7444 
 7445         public class ByteConstantRule : System.Text.Parsing.RuleParser
 7446         {
 7447             public ByteConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7448             {
 7449                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7450                 SetValueTypeName(ToUtf32("ConstantValue*"));
 7451             }
 7452             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7453             {
 7454                 parsingData->PushContext(Id(), new Context());
 7455                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7456                 UniquePtr<Object> context_value = stack.Pop();
 7457                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7458             }
 7459             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7460             {
 7461                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7462                 if (matched)
 7463                 {
 7464                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 7465                 }
 7466                 parsingData->PopContext(Id());
 7467             }
 7468             public override void Link()
 7469             {
 7470                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7471                 a0ActionParser->SetAction(A0Action);
 7472                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 7473                 typeNonterminalParser->SetPre(Pretype);
 7474                 typeNonterminalParser->SetPost(Posttype);
 7475                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 7476                 valNonterminalParser->SetPost(Postval);
 7477             }
 7478             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7479             {
 7480                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7481                 context->value = context->context->MakeByteValue(cast<ByteType*>(context->fromtype), context->fromval);
 7482             }
 7483             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7484             {
 7485                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7486                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7487             }
 7488             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7489             {
 7490                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7491                 if (matched)
 7492                 {
 7493                     UniquePtr<Object> fromtype_value = stack.Pop();
 7494                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 7495                 }
 7496             }
 7497             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7498             {
 7499                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7500                 if (matched)
 7501                 {
 7502                     UniquePtr<Object> fromval_value = stack.Pop();
 7503                     context->fromval = *cast<ValueObject<byte>*>(fromval_value.Get());
 7504                 }
 7505             }
 7506             public class Context : System.Text.Parsing.Context
 7507             {
 7508                 public Context() : context(), value(), fromtype(), fromval()
 7509                 {
 7510                 }
 7511                 public cmsx.intermediate.Context* context;
 7512                 public ConstantValue* value;
 7513                 public Type* fromtype;
 7514                 public byte fromval;
 7515             }
 7516         }
 7517 
 7518         public class ByteValueRule : System.Text.Parsing.RuleParser
 7519         {
 7520             public ByteValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7521             {
 7522                 SetValueTypeName(ToUtf32("byte"));
 7523             }
 7524             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7525             {
 7526                 parsingData->PushContext(Id(), new Context());
 7527                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7528             }
 7529             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7530             {
 7531                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7532                 if (matched)
 7533                 {
 7534                     stack.Push(UniquePtr<Object>(new ValueObject<byte>(context->value)));
 7535                 }
 7536                 parsingData->PopContext(Id());
 7537             }
 7538             public override void Link()
 7539             {
 7540                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7541                 a0ActionParser->SetAction(A0Action);
 7542                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 7543                 xNonterminalParser->SetPost(Postx);
 7544             }
 7545             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7546             {
 7547                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7548                 context->value = context->fromx;
 7549             }
 7550             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7551             {
 7552                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7553                 if (matched)
 7554                 {
 7555                     UniquePtr<Object> fromx_value = stack.Pop();
 7556                     context->fromx = *cast<ValueObject<byte>*>(fromx_value.Get());
 7557                 }
 7558             }
 7559             public class Context : System.Text.Parsing.Context
 7560             {
 7561                 public Context() : value(), fromx()
 7562                 {
 7563                 }
 7564                 public byte value;
 7565                 public byte fromx;
 7566             }
 7567         }
 7568 
 7569         public class ShortConstantRule : System.Text.Parsing.RuleParser
 7570         {
 7571             public ShortConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7572             {
 7573                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7574                 SetValueTypeName(ToUtf32("ConstantValue*"));
 7575             }
 7576             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7577             {
 7578                 parsingData->PushContext(Id(), new Context());
 7579                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7580                 UniquePtr<Object> context_value = stack.Pop();
 7581                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7582             }
 7583             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7584             {
 7585                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7586                 if (matched)
 7587                 {
 7588                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 7589                 }
 7590                 parsingData->PopContext(Id());
 7591             }
 7592             public override void Link()
 7593             {
 7594                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7595                 a0ActionParser->SetAction(A0Action);
 7596                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 7597                 typeNonterminalParser->SetPre(Pretype);
 7598                 typeNonterminalParser->SetPost(Posttype);
 7599                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 7600                 valNonterminalParser->SetPost(Postval);
 7601             }
 7602             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7603             {
 7604                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7605                 context->value = context->context->MakeShortValue(cast<ShortType*>(context->fromtype), context->fromval);
 7606             }
 7607             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7608             {
 7609                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7610                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7611             }
 7612             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7613             {
 7614                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7615                 if (matched)
 7616                 {
 7617                     UniquePtr<Object> fromtype_value = stack.Pop();
 7618                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 7619                 }
 7620             }
 7621             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7622             {
 7623                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7624                 if (matched)
 7625                 {
 7626                     UniquePtr<Object> fromval_value = stack.Pop();
 7627                     context->fromval = *cast<ValueObject<short>*>(fromval_value.Get());
 7628                 }
 7629             }
 7630             public class Context : System.Text.Parsing.Context
 7631             {
 7632                 public Context() : context(), value(), fromtype(), fromval()
 7633                 {
 7634                 }
 7635                 public cmsx.intermediate.Context* context;
 7636                 public ConstantValue* value;
 7637                 public Type* fromtype;
 7638                 public short fromval;
 7639             }
 7640         }
 7641 
 7642         public class ShortValueRule : System.Text.Parsing.RuleParser
 7643         {
 7644             public ShortValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7645             {
 7646                 SetValueTypeName(ToUtf32("short"));
 7647             }
 7648             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7649             {
 7650                 parsingData->PushContext(Id(), new Context());
 7651                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7652             }
 7653             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7654             {
 7655                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7656                 if (matched)
 7657                 {
 7658                     stack.Push(UniquePtr<Object>(new ValueObject<short>(context->value)));
 7659                 }
 7660                 parsingData->PopContext(Id());
 7661             }
 7662             public override void Link()
 7663             {
 7664                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7665                 a0ActionParser->SetAction(A0Action);
 7666                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 7667                 xNonterminalParser->SetPost(Postx);
 7668             }
 7669             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7670             {
 7671                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7672                 context->value = context->fromx;
 7673             }
 7674             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7675             {
 7676                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7677                 if (matched)
 7678                 {
 7679                     UniquePtr<Object> fromx_value = stack.Pop();
 7680                     context->fromx = *cast<ValueObject<short>*>(fromx_value.Get());
 7681                 }
 7682             }
 7683             public class Context : System.Text.Parsing.Context
 7684             {
 7685                 public Context() : value(), fromx()
 7686                 {
 7687                 }
 7688                 public short value;
 7689                 public short fromx;
 7690             }
 7691         }
 7692 
 7693         public class UShortConstantRule : System.Text.Parsing.RuleParser
 7694         {
 7695             public UShortConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7696             {
 7697                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7698                 SetValueTypeName(ToUtf32("ConstantValue*"));
 7699             }
 7700             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7701             {
 7702                 parsingData->PushContext(Id(), new Context());
 7703                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7704                 UniquePtr<Object> context_value = stack.Pop();
 7705                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7706             }
 7707             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7708             {
 7709                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7710                 if (matched)
 7711                 {
 7712                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 7713                 }
 7714                 parsingData->PopContext(Id());
 7715             }
 7716             public override void Link()
 7717             {
 7718                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7719                 a0ActionParser->SetAction(A0Action);
 7720                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 7721                 typeNonterminalParser->SetPre(Pretype);
 7722                 typeNonterminalParser->SetPost(Posttype);
 7723                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 7724                 valNonterminalParser->SetPost(Postval);
 7725             }
 7726             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7727             {
 7728                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7729                 context->value = context->context->MakeUShortValue(cast<UShortType*>(context->fromtype), context->fromval);
 7730             }
 7731             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7732             {
 7733                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7734                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7735             }
 7736             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7737             {
 7738                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7739                 if (matched)
 7740                 {
 7741                     UniquePtr<Object> fromtype_value = stack.Pop();
 7742                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 7743                 }
 7744             }
 7745             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7746             {
 7747                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7748                 if (matched)
 7749                 {
 7750                     UniquePtr<Object> fromval_value = stack.Pop();
 7751                     context->fromval = *cast<ValueObject<ushort>*>(fromval_value.Get());
 7752                 }
 7753             }
 7754             public class Context : System.Text.Parsing.Context
 7755             {
 7756                 public Context() : context(), value(), fromtype(), fromval()
 7757                 {
 7758                 }
 7759                 public cmsx.intermediate.Context* context;
 7760                 public ConstantValue* value;
 7761                 public Type* fromtype;
 7762                 public ushort fromval;
 7763             }
 7764         }
 7765 
 7766         public class UShortValueRule : System.Text.Parsing.RuleParser
 7767         {
 7768             public UShortValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7769             {
 7770                 SetValueTypeName(ToUtf32("ushort"));
 7771             }
 7772             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7773             {
 7774                 parsingData->PushContext(Id(), new Context());
 7775                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7776             }
 7777             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7778             {
 7779                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7780                 if (matched)
 7781                 {
 7782                     stack.Push(UniquePtr<Object>(new ValueObject<ushort>(context->value)));
 7783                 }
 7784                 parsingData->PopContext(Id());
 7785             }
 7786             public override void Link()
 7787             {
 7788                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7789                 a0ActionParser->SetAction(A0Action);
 7790                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 7791                 xNonterminalParser->SetPost(Postx);
 7792             }
 7793             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7794             {
 7795                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7796                 context->value = context->fromx;
 7797             }
 7798             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7799             {
 7800                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7801                 if (matched)
 7802                 {
 7803                     UniquePtr<Object> fromx_value = stack.Pop();
 7804                     context->fromx = *cast<ValueObject<ushort>*>(fromx_value.Get());
 7805                 }
 7806             }
 7807             public class Context : System.Text.Parsing.Context
 7808             {
 7809                 public Context() : value(), fromx()
 7810                 {
 7811                 }
 7812                 public ushort value;
 7813                 public ushort fromx;
 7814             }
 7815         }
 7816 
 7817         public class IntConstantRule : System.Text.Parsing.RuleParser
 7818         {
 7819             public IntConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7820             {
 7821                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7822                 SetValueTypeName(ToUtf32("ConstantValue*"));
 7823             }
 7824             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7825             {
 7826                 parsingData->PushContext(Id(), new Context());
 7827                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7828                 UniquePtr<Object> context_value = stack.Pop();
 7829                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7830             }
 7831             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7832             {
 7833                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7834                 if (matched)
 7835                 {
 7836                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 7837                 }
 7838                 parsingData->PopContext(Id());
 7839             }
 7840             public override void Link()
 7841             {
 7842                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7843                 a0ActionParser->SetAction(A0Action);
 7844                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 7845                 typeNonterminalParser->SetPre(Pretype);
 7846                 typeNonterminalParser->SetPost(Posttype);
 7847                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 7848                 valNonterminalParser->SetPost(Postval);
 7849             }
 7850             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7851             {
 7852                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7853                 context->value = context->context->MakeIntValue(cast<IntType*>(context->fromtype), context->fromval);
 7854             }
 7855             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7856             {
 7857                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7858                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7859             }
 7860             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7861             {
 7862                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7863                 if (matched)
 7864                 {
 7865                     UniquePtr<Object> fromtype_value = stack.Pop();
 7866                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 7867                 }
 7868             }
 7869             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7870             {
 7871                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7872                 if (matched)
 7873                 {
 7874                     UniquePtr<Object> fromval_value = stack.Pop();
 7875                     context->fromval = *cast<ValueObject<int>*>(fromval_value.Get());
 7876                 }
 7877             }
 7878             public class Context : System.Text.Parsing.Context
 7879             {
 7880                 public Context() : context(), value(), fromtype(), fromval()
 7881                 {
 7882                 }
 7883                 public cmsx.intermediate.Context* context;
 7884                 public ConstantValue* value;
 7885                 public Type* fromtype;
 7886                 public int fromval;
 7887             }
 7888         }
 7889 
 7890         public class IntValueRule : System.Text.Parsing.RuleParser
 7891         {
 7892             public IntValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7893             {
 7894                 SetValueTypeName(ToUtf32("int"));
 7895             }
 7896             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7897             {
 7898                 parsingData->PushContext(Id(), new Context());
 7899                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7900             }
 7901             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7902             {
 7903                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7904                 if (matched)
 7905                 {
 7906                     stack.Push(UniquePtr<Object>(new ValueObject<int>(context->value)));
 7907                 }
 7908                 parsingData->PopContext(Id());
 7909             }
 7910             public override void Link()
 7911             {
 7912                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7913                 a0ActionParser->SetAction(A0Action);
 7914                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 7915                 xNonterminalParser->SetPost(Postx);
 7916             }
 7917             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7918             {
 7919                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7920                 context->value = context->fromx;
 7921             }
 7922             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7923             {
 7924                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7925                 if (matched)
 7926                 {
 7927                     UniquePtr<Object> fromx_value = stack.Pop();
 7928                     context->fromx = *cast<ValueObject<int>*>(fromx_value.Get());
 7929                 }
 7930             }
 7931             public class Context : System.Text.Parsing.Context
 7932             {
 7933                 public Context() : value(), fromx()
 7934                 {
 7935                 }
 7936                 public int value;
 7937                 public int fromx;
 7938             }
 7939         }
 7940 
 7941         public class UIntConstantRule : System.Text.Parsing.RuleParser
 7942         {
 7943             public UIntConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7944             {
 7945                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7946                 SetValueTypeName(ToUtf32("ConstantValue*"));
 7947             }
 7948             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7949             {
 7950                 parsingData->PushContext(Id(), new Context());
 7951                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7952                 UniquePtr<Object> context_value = stack.Pop();
 7953                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7954             }
 7955             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7956             {
 7957                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7958                 if (matched)
 7959                 {
 7960                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 7961                 }
 7962                 parsingData->PopContext(Id());
 7963             }
 7964             public override void Link()
 7965             {
 7966                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7967                 a0ActionParser->SetAction(A0Action);
 7968                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 7969                 typeNonterminalParser->SetPre(Pretype);
 7970                 typeNonterminalParser->SetPost(Posttype);
 7971                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 7972                 valNonterminalParser->SetPost(Postval);
 7973             }
 7974             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7975             {
 7976                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7977                 context->value = context->context->MakeUIntValue(cast<UIntType*>(context->fromtype), context->fromval);
 7978             }
 7979             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7980             {
 7981                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7982                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7983             }
 7984             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7985             {
 7986                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7987                 if (matched)
 7988                 {
 7989                     UniquePtr<Object> fromtype_value = stack.Pop();
 7990                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 7991                 }
 7992             }
 7993             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7994             {
 7995                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7996                 if (matched)
 7997                 {
 7998                     UniquePtr<Object> fromval_value = stack.Pop();
 7999                     context->fromval = *cast<ValueObject<uint>*>(fromval_value.Get());
 8000                 }
 8001             }
 8002             public class Context : System.Text.Parsing.Context
 8003             {
 8004                 public Context() : context(), value(), fromtype(), fromval()
 8005                 {
 8006                 }
 8007                 public cmsx.intermediate.Context* context;
 8008                 public ConstantValue* value;
 8009                 public Type* fromtype;
 8010                 public uint fromval;
 8011             }
 8012         }
 8013 
 8014         public class UIntValueRule : System.Text.Parsing.RuleParser
 8015         {
 8016             public UIntValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8017             {
 8018                 SetValueTypeName(ToUtf32("uint"));
 8019             }
 8020             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8021             {
 8022                 parsingData->PushContext(Id(), new Context());
 8023                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8024             }
 8025             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8026             {
 8027                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8028                 if (matched)
 8029                 {
 8030                     stack.Push(UniquePtr<Object>(new ValueObject<uint>(context->value)));
 8031                 }
 8032                 parsingData->PopContext(Id());
 8033             }
 8034             public override void Link()
 8035             {
 8036                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8037                 a0ActionParser->SetAction(A0Action);
 8038                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8039                 xNonterminalParser->SetPost(Postx);
 8040             }
 8041             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8042             {
 8043                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8044                 context->value = context->fromx;
 8045             }
 8046             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8047             {
 8048                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8049                 if (matched)
 8050                 {
 8051                     UniquePtr<Object> fromx_value = stack.Pop();
 8052                     context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
 8053                 }
 8054             }
 8055             public class Context : System.Text.Parsing.Context
 8056             {
 8057                 public Context() : value(), fromx()
 8058                 {
 8059                 }
 8060                 public uint value;
 8061                 public uint fromx;
 8062             }
 8063         }
 8064 
 8065         public class LongConstantRule : System.Text.Parsing.RuleParser
 8066         {
 8067             public LongConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8068             {
 8069                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8070                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8071             }
 8072             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8073             {
 8074                 parsingData->PushContext(Id(), new Context());
 8075                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8076                 UniquePtr<Object> context_value = stack.Pop();
 8077                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8078             }
 8079             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8080             {
 8081                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8082                 if (matched)
 8083                 {
 8084                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8085                 }
 8086                 parsingData->PopContext(Id());
 8087             }
 8088             public override void Link()
 8089             {
 8090                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8091                 a0ActionParser->SetAction(A0Action);
 8092                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8093                 typeNonterminalParser->SetPre(Pretype);
 8094                 typeNonterminalParser->SetPost(Posttype);
 8095                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8096                 valNonterminalParser->SetPost(Postval);
 8097             }
 8098             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8099             {
 8100                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8101                 context->value = context->context->MakeLongValue(cast<LongType*>(context->fromtype), context->fromval);
 8102             }
 8103             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8104             {
 8105                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8106                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8107             }
 8108             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8109             {
 8110                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8111                 if (matched)
 8112                 {
 8113                     UniquePtr<Object> fromtype_value = stack.Pop();
 8114                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8115                 }
 8116             }
 8117             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8118             {
 8119                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8120                 if (matched)
 8121                 {
 8122                     UniquePtr<Object> fromval_value = stack.Pop();
 8123                     context->fromval = *cast<ValueObject<long>*>(fromval_value.Get());
 8124                 }
 8125             }
 8126             public class Context : System.Text.Parsing.Context
 8127             {
 8128                 public Context() : context(), value(), fromtype(), fromval()
 8129                 {
 8130                 }
 8131                 public cmsx.intermediate.Context* context;
 8132                 public ConstantValue* value;
 8133                 public Type* fromtype;
 8134                 public long fromval;
 8135             }
 8136         }
 8137 
 8138         public class LongValueRule : System.Text.Parsing.RuleParser
 8139         {
 8140             public LongValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8141             {
 8142                 SetValueTypeName(ToUtf32("long"));
 8143             }
 8144             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8145             {
 8146                 parsingData->PushContext(Id(), new Context());
 8147                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8148             }
 8149             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8150             {
 8151                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8152                 if (matched)
 8153                 {
 8154                     stack.Push(UniquePtr<Object>(new ValueObject<long>(context->value)));
 8155                 }
 8156                 parsingData->PopContext(Id());
 8157             }
 8158             public override void Link()
 8159             {
 8160                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8161                 a0ActionParser->SetAction(A0Action);
 8162                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8163                 xNonterminalParser->SetPost(Postx);
 8164             }
 8165             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8166             {
 8167                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8168                 context->value = context->fromx;
 8169             }
 8170             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8171             {
 8172                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8173                 if (matched)
 8174                 {
 8175                     UniquePtr<Object> fromx_value = stack.Pop();
 8176                     context->fromx = *cast<ValueObject<long>*>(fromx_value.Get());
 8177                 }
 8178             }
 8179             public class Context : System.Text.Parsing.Context
 8180             {
 8181                 public Context() : value(), fromx()
 8182                 {
 8183                 }
 8184                 public long value;
 8185                 public long fromx;
 8186             }
 8187         }
 8188 
 8189         public class ULongConstantRule : System.Text.Parsing.RuleParser
 8190         {
 8191             public ULongConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8192             {
 8193                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8194                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8195             }
 8196             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8197             {
 8198                 parsingData->PushContext(Id(), new Context());
 8199                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8200                 UniquePtr<Object> context_value = stack.Pop();
 8201                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8202             }
 8203             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8204             {
 8205                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8206                 if (matched)
 8207                 {
 8208                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8209                 }
 8210                 parsingData->PopContext(Id());
 8211             }
 8212             public override void Link()
 8213             {
 8214                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8215                 a0ActionParser->SetAction(A0Action);
 8216                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8217                 typeNonterminalParser->SetPre(Pretype);
 8218                 typeNonterminalParser->SetPost(Posttype);
 8219                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8220                 valNonterminalParser->SetPost(Postval);
 8221             }
 8222             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8223             {
 8224                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8225                 context->value = context->context->MakeULongValue(cast<ULongType*>(context->fromtype), context->fromval);
 8226             }
 8227             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8228             {
 8229                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8230                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8231             }
 8232             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8233             {
 8234                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8235                 if (matched)
 8236                 {
 8237                     UniquePtr<Object> fromtype_value = stack.Pop();
 8238                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8239                 }
 8240             }
 8241             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8242             {
 8243                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8244                 if (matched)
 8245                 {
 8246                     UniquePtr<Object> fromval_value = stack.Pop();
 8247                     context->fromval = *cast<ValueObject<ulong>*>(fromval_value.Get());
 8248                 }
 8249             }
 8250             public class Context : System.Text.Parsing.Context
 8251             {
 8252                 public Context() : context(), value(), fromtype(), fromval()
 8253                 {
 8254                 }
 8255                 public cmsx.intermediate.Context* context;
 8256                 public ConstantValue* value;
 8257                 public Type* fromtype;
 8258                 public ulong fromval;
 8259             }
 8260         }
 8261 
 8262         public class ULongValueRule : System.Text.Parsing.RuleParser
 8263         {
 8264             public ULongValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8265             {
 8266                 SetValueTypeName(ToUtf32("ulong"));
 8267             }
 8268             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8269             {
 8270                 parsingData->PushContext(Id(), new Context());
 8271                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8272             }
 8273             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8274             {
 8275                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8276                 if (matched)
 8277                 {
 8278                     stack.Push(UniquePtr<Object>(new ValueObject<ulong>(context->value)));
 8279                 }
 8280                 parsingData->PopContext(Id());
 8281             }
 8282             public override void Link()
 8283             {
 8284                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8285                 a0ActionParser->SetAction(A0Action);
 8286                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8287                 xNonterminalParser->SetPost(Postx);
 8288             }
 8289             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8290             {
 8291                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8292                 context->value = context->fromx;
 8293             }
 8294             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8295             {
 8296                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8297                 if (matched)
 8298                 {
 8299                     UniquePtr<Object> fromx_value = stack.Pop();
 8300                     context->fromx = *cast<ValueObject<ulong>*>(fromx_value.Get());
 8301                 }
 8302             }
 8303             public class Context : System.Text.Parsing.Context
 8304             {
 8305                 public Context() : value(), fromx()
 8306                 {
 8307                 }
 8308                 public ulong value;
 8309                 public ulong fromx;
 8310             }
 8311         }
 8312 
 8313         public class FloatConstantRule : System.Text.Parsing.RuleParser
 8314         {
 8315             public FloatConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8316             {
 8317                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8318                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8319             }
 8320             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8321             {
 8322                 parsingData->PushContext(Id(), new Context());
 8323                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8324                 UniquePtr<Object> context_value = stack.Pop();
 8325                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8326             }
 8327             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8328             {
 8329                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8330                 if (matched)
 8331                 {
 8332                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8333                 }
 8334                 parsingData->PopContext(Id());
 8335             }
 8336             public override void Link()
 8337             {
 8338                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8339                 a0ActionParser->SetAction(A0Action);
 8340                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8341                 typeNonterminalParser->SetPre(Pretype);
 8342                 typeNonterminalParser->SetPost(Posttype);
 8343                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8344                 valNonterminalParser->SetPost(Postval);
 8345             }
 8346             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8347             {
 8348                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8349                 context->value = context->context->MakeFloatValue(cast<FloatType*>(context->fromtype), context->fromval);
 8350             }
 8351             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8352             {
 8353                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8354                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8355             }
 8356             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8357             {
 8358                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8359                 if (matched)
 8360                 {
 8361                     UniquePtr<Object> fromtype_value = stack.Pop();
 8362                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8363                 }
 8364             }
 8365             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8366             {
 8367                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8368                 if (matched)
 8369                 {
 8370                     UniquePtr<Object> fromval_value = stack.Pop();
 8371                     context->fromval = *cast<ValueObject<float>*>(fromval_value.Get());
 8372                 }
 8373             }
 8374             public class Context : System.Text.Parsing.Context
 8375             {
 8376                 public Context() : context(), value(), fromtype(), fromval()
 8377                 {
 8378                 }
 8379                 public cmsx.intermediate.Context* context;
 8380                 public ConstantValue* value;
 8381                 public Type* fromtype;
 8382                 public float fromval;
 8383             }
 8384         }
 8385 
 8386         public class FloatValueRule : System.Text.Parsing.RuleParser
 8387         {
 8388             public FloatValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8389             {
 8390                 SetValueTypeName(ToUtf32("float"));
 8391             }
 8392             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8393             {
 8394                 parsingData->PushContext(Id(), new Context());
 8395                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8396             }
 8397             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8398             {
 8399                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8400                 if (matched)
 8401                 {
 8402                     stack.Push(UniquePtr<Object>(new ValueObject<float>(context->value)));
 8403                 }
 8404                 parsingData->PopContext(Id());
 8405             }
 8406             public override void Link()
 8407             {
 8408                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8409                 a0ActionParser->SetAction(A0Action);
 8410                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8411                 xNonterminalParser->SetPost(Postx);
 8412             }
 8413             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8414             {
 8415                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8416                 context->value = context->fromx;
 8417             }
 8418             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8419             {
 8420                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8421                 if (matched)
 8422                 {
 8423                     UniquePtr<Object> fromx_value = stack.Pop();
 8424                     context->fromx = *cast<ValueObject<float>*>(fromx_value.Get());
 8425                 }
 8426             }
 8427             public class Context : System.Text.Parsing.Context
 8428             {
 8429                 public Context() : value(), fromx()
 8430                 {
 8431                 }
 8432                 public float value;
 8433                 public float fromx;
 8434             }
 8435         }
 8436 
 8437         public class DoubleConstantRule : System.Text.Parsing.RuleParser
 8438         {
 8439             public DoubleConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8440             {
 8441                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8442                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8443             }
 8444             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8445             {
 8446                 parsingData->PushContext(Id(), new Context());
 8447                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8448                 UniquePtr<Object> context_value = stack.Pop();
 8449                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8450             }
 8451             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8452             {
 8453                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8454                 if (matched)
 8455                 {
 8456                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8457                 }
 8458                 parsingData->PopContext(Id());
 8459             }
 8460             public override void Link()
 8461             {
 8462                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8463                 a0ActionParser->SetAction(A0Action);
 8464                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8465                 typeNonterminalParser->SetPre(Pretype);
 8466                 typeNonterminalParser->SetPost(Posttype);
 8467                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8468                 valNonterminalParser->SetPost(Postval);
 8469             }
 8470             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8471             {
 8472                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8473                 context->value = context->context->MakeDoubleValue(cast<DoubleType*>(context->fromtype), context->fromval);
 8474             }
 8475             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8476             {
 8477                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8478                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8479             }
 8480             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8481             {
 8482                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8483                 if (matched)
 8484                 {
 8485                     UniquePtr<Object> fromtype_value = stack.Pop();
 8486                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8487                 }
 8488             }
 8489             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8490             {
 8491                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8492                 if (matched)
 8493                 {
 8494                     UniquePtr<Object> fromval_value = stack.Pop();
 8495                     context->fromval = *cast<ValueObject<double>*>(fromval_value.Get());
 8496                 }
 8497             }
 8498             public class Context : System.Text.Parsing.Context
 8499             {
 8500                 public Context() : context(), value(), fromtype(), fromval()
 8501                 {
 8502                 }
 8503                 public cmsx.intermediate.Context* context;
 8504                 public ConstantValue* value;
 8505                 public Type* fromtype;
 8506                 public double fromval;
 8507             }
 8508         }
 8509 
 8510         public class DoubleValueRule : System.Text.Parsing.RuleParser
 8511         {
 8512             public DoubleValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8513             {
 8514                 SetValueTypeName(ToUtf32("double"));
 8515             }
 8516             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8517             {
 8518                 parsingData->PushContext(Id(), new Context());
 8519                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8520             }
 8521             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8522             {
 8523                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8524                 if (matched)
 8525                 {
 8526                     stack.Push(UniquePtr<Object>(new ValueObject<double>(context->value)));
 8527                 }
 8528                 parsingData->PopContext(Id());
 8529             }
 8530             public override void Link()
 8531             {
 8532                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8533                 a0ActionParser->SetAction(A0Action);
 8534                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8535                 xNonterminalParser->SetPost(Postx);
 8536             }
 8537             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8538             {
 8539                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8540                 context->value = context->fromx;
 8541             }
 8542             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8543             {
 8544                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8545                 if (matched)
 8546                 {
 8547                     UniquePtr<Object> fromx_value = stack.Pop();
 8548                     context->fromx = *cast<ValueObject<double>*>(fromx_value.Get());
 8549                 }
 8550             }
 8551             public class Context : System.Text.Parsing.Context
 8552             {
 8553                 public Context() : value(), fromx()
 8554                 {
 8555                 }
 8556                 public double value;
 8557                 public double fromx;
 8558             }
 8559         }
 8560 
 8561         public class PtrConstantRule : System.Text.Parsing.RuleParser
 8562         {
 8563             public PtrConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8564             {
 8565                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8566                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8567             }
 8568             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8569             {
 8570                 parsingData->PushContext(Id(), new Context());
 8571                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8572                 UniquePtr<Object> context_value = stack.Pop();
 8573                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8574             }
 8575             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8576             {
 8577                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8578                 if (matched)
 8579                 {
 8580                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8581                 }
 8582                 parsingData->PopContext(Id());
 8583             }
 8584             public override void Link()
 8585             {
 8586                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8587                 a0ActionParser->SetAction(A0Action);
 8588                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 8589                 a1ActionParser->SetAction(A1Action);
 8590                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8591                 typeNonterminalParser->SetPre(Pretype);
 8592                 typeNonterminalParser->SetPost(Posttype);
 8593             }
 8594             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8595             {
 8596                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8597                 context->value = cast<PtrType*>(context->fromtype)->DefaultValue();
 8598             }
 8599             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8600             {
 8601                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8602                 pass = IsPtrType(context->fromtype);
 8603             }
 8604             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8605             {
 8606                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8607                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8608             }
 8609             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8610             {
 8611                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8612                 if (matched)
 8613                 {
 8614                     UniquePtr<Object> fromtype_value = stack.Pop();
 8615                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8616                 }
 8617             }
 8618             public class Context : System.Text.Parsing.Context
 8619             {
 8620                 public Context() : context(), value(), fromtype()
 8621                 {
 8622                 }
 8623                 public cmsx.intermediate.Context* context;
 8624                 public ConstantValue* value;
 8625                 public Type* fromtype;
 8626             }
 8627         }
 8628 
 8629         public class ArrayConstantRule : System.Text.Parsing.RuleParser
 8630         {
 8631             public ArrayConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8632             {
 8633                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8634                 SetValueTypeName(ToUtf32("ArrayValue*"));
 8635             }
 8636             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8637             {
 8638                 parsingData->PushContext(Id(), new Context());
 8639                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8640                 UniquePtr<Object> context_value = stack.Pop();
 8641                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8642             }
 8643             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8644             {
 8645                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8646                 if (matched)
 8647                 {
 8648                     stack.Push(UniquePtr<Object>(new ValueObject<ArrayValue*>(context->value)));
 8649                 }
 8650                 parsingData->PopContext(Id());
 8651             }
 8652             public override void Link()
 8653             {
 8654                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8655                 a0ActionParser->SetAction(A0Action);
 8656                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 8657                 a1ActionParser->SetAction(A1Action);
 8658                 NonterminalParser* elementNonterminalParser = GetNonterminal(ToUtf32("element"));
 8659                 elementNonterminalParser->SetPre(Preelement);
 8660                 elementNonterminalParser->SetPost(Postelement);
 8661             }
 8662             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8663             {
 8664                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8665                 context->value = context->context->MakeArrayValue();
 8666             }
 8667             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8668             {
 8669                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8670                 context->value->AddElement(context->fromelement);
 8671             }
 8672             public void Preelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8673             {
 8674                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8675                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8676             }
 8677             public void Postelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8678             {
 8679                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8680                 if (matched)
 8681                 {
 8682                     UniquePtr<Object> fromelement_value = stack.Pop();
 8683                     context->fromelement = *cast<ValueObject<ConstantValue*>*>(fromelement_value.Get());
 8684                 }
 8685             }
 8686             public class Context : System.Text.Parsing.Context
 8687             {
 8688                 public Context() : context(), value(), fromelement()
 8689                 {
 8690                 }
 8691                 public cmsx.intermediate.Context* context;
 8692                 public ArrayValue* value;
 8693                 public ConstantValue* fromelement;
 8694             }
 8695         }
 8696 
 8697         public class StructureConstantRule : System.Text.Parsing.RuleParser
 8698         {
 8699             public StructureConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8700             {
 8701                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8702                 SetValueTypeName(ToUtf32("StructureValue*"));
 8703             }
 8704             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8705             {
 8706                 parsingData->PushContext(Id(), new Context());
 8707                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8708                 UniquePtr<Object> context_value = stack.Pop();
 8709                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8710             }
 8711             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8712             {
 8713                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8714                 if (matched)
 8715                 {
 8716                     stack.Push(UniquePtr<Object>(new ValueObject<StructureValue*>(context->value)));
 8717                 }
 8718                 parsingData->PopContext(Id());
 8719             }
 8720             public override void Link()
 8721             {
 8722                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8723                 a0ActionParser->SetAction(A0Action);
 8724                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 8725                 a1ActionParser->SetAction(A1Action);
 8726                 NonterminalParser* memberNonterminalParser = GetNonterminal(ToUtf32("member"));
 8727                 memberNonterminalParser->SetPre(Premember);
 8728                 memberNonterminalParser->SetPost(Postmember);
 8729             }
 8730             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8731             {
 8732                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8733                 context->value = context->context->MakeStructureValue();
 8734             }
 8735             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8736             {
 8737                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8738                 context->value->AddMember(context->frommember);
 8739             }
 8740             public void Premember(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8741             {
 8742                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8743                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8744             }
 8745             public void Postmember(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8746             {
 8747                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8748                 if (matched)
 8749                 {
 8750                     UniquePtr<Object> frommember_value = stack.Pop();
 8751                     context->frommember = *cast<ValueObject<ConstantValue*>*>(frommember_value.Get());
 8752                 }
 8753             }
 8754             public class Context : System.Text.Parsing.Context
 8755             {
 8756                 public Context() : context(), value(), frommember()
 8757                 {
 8758                 }
 8759                 public cmsx.intermediate.Context* context;
 8760                 public StructureValue* value;
 8761                 public ConstantValue* frommember;
 8762             }
 8763         }
 8764 
 8765         public override void GetReferencedGrammars()
 8766         {
 8767             ParsingDomain* pd = Domain();
 8768             Grammar* grammar0 = pd->GetGrammar(ToUtf32("System.Text.Parsing.stdlib"));
 8769             if (grammar0 == null)
 8770             {
 8771                 grammar0 = new System.Text.Parsing.stdlib(pd);
 8772             }
 8773             AddGrammarReference(grammar0);
 8774         }
 8775         public override void CreateRules()
 8776         {
 8777             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("identifier"), this, ToUtf32("System.Text.Parsing.stdlib.identifier")));
 8778             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("newline"), this, ToUtf32("System.Text.Parsing.stdlib.newline")));
 8779             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("bool"), this, ToUtf32("System.Text.Parsing.stdlib.bool")));
 8780             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("sbyte"), this, ToUtf32("System.Text.Parsing.stdlib.sbyte")));
 8781             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("byte"), this, ToUtf32("System.Text.Parsing.stdlib.byte")));
 8782             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("short"), this, ToUtf32("System.Text.Parsing.stdlib.short")));
 8783             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ushort"), this, ToUtf32("System.Text.Parsing.stdlib.ushort")));
 8784             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("int"), this, ToUtf32("System.Text.Parsing.stdlib.int")));
 8785             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("uint"), this, ToUtf32("System.Text.Parsing.stdlib.uint")));
 8786             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("long"), this, ToUtf32("System.Text.Parsing.stdlib.long")));
 8787             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ulong"), this, ToUtf32("System.Text.Parsing.stdlib.ulong")));
 8788             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("float"), this, ToUtf32("System.Text.Parsing.stdlib.float")));
 8789             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("double"), this, ToUtf32("System.Text.Parsing.stdlib.double")));
 8790             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("spaces"), this, ToUtf32("System.Text.Parsing.stdlib.spaces")));
 8791             AddRule(new IntermediateCodeFileRule(ToUtf32("IntermediateCodeFile"), GetScope(), Domain()->GetNextRuleId(), 
 8792                 new System.Text.Parsing.SequenceParser(
 8793                     new System.Text.Parsing.SequenceParser(
 8794                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8795                             new System.Text.Parsing.EmptyParser()), 
 8796                         new System.Text.Parsing.OptionalParser(
 8797                             new System.Text.Parsing.NonterminalParser(ToUtf32("TypeDeclarations"), ToUtf32("TypeDeclarations"), 1))), 
 8798                     new System.Text.Parsing.OptionalParser(
 8799                         new System.Text.Parsing.NonterminalParser(ToUtf32("Functions"), ToUtf32("Functions"), 1)))));
 8800             AddRule(new TypeDeclarationsRule(ToUtf32("TypeDeclarations"), GetScope(), Domain()->GetNextRuleId(), 
 8801                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8802                     new System.Text.Parsing.GroupingParser(
 8803                         new System.Text.Parsing.SequenceParser(
 8804                             new System.Text.Parsing.SequenceParser(
 8805                                 new System.Text.Parsing.SequenceParser(
 8806                                     new System.Text.Parsing.KeywordParser(ToUtf32("types")), 
 8807                                     new System.Text.Parsing.ExpectationParser(
 8808                                         new System.Text.Parsing.CharParser('{'))), 
 8809                                 new System.Text.Parsing.KleeneStarParser(
 8810                                     new System.Text.Parsing.NonterminalParser(ToUtf32("TypeDeclaration"), ToUtf32("TypeDeclaration"), 1))), 
 8811                             new System.Text.Parsing.ExpectationParser(
 8812                                 new System.Text.Parsing.CharParser('}')))))));
 8813             AddRule(new DataDefinitionsRule(ToUtf32("DataDefinitions"), GetScope(), Domain()->GetNextRuleId(), 
 8814                 new System.Text.Parsing.SequenceParser(
 8815                     new System.Text.Parsing.SequenceParser(
 8816                         new System.Text.Parsing.SequenceParser(
 8817                             new System.Text.Parsing.KeywordParser(ToUtf32("data")), 
 8818                             new System.Text.Parsing.ExpectationParser(
 8819                                 new System.Text.Parsing.CharParser('{'))), 
 8820                         new System.Text.Parsing.KleeneStarParser(
 8821                             new System.Text.Parsing.NonterminalParser(ToUtf32("DataDefinition"), ToUtf32("DataDefinition"), 1))), 
 8822                     new System.Text.Parsing.ExpectationParser(
 8823                         new System.Text.Parsing.CharParser('}')))));
 8824             AddRule(new FunctionsRule(ToUtf32("Functions"), GetScope(), Domain()->GetNextRuleId(), 
 8825                 new System.Text.Parsing.KleeneStarParser(
 8826                     new System.Text.Parsing.NonterminalParser(ToUtf32("Function"), ToUtf32("Function"), 1))));
 8827             AddRule(new FunctionRule(ToUtf32("Function"), GetScope(), Domain()->GetNextRuleId(), 
 8828                 new System.Text.Parsing.SequenceParser(
 8829                     new System.Text.Parsing.SequenceParser(
 8830                         new System.Text.Parsing.SequenceParser(
 8831                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8832                                 new System.Text.Parsing.NonterminalParser(ToUtf32("function"), ToUtf32("FunctionHeader"), 1)), 
 8833                             new System.Text.Parsing.ExpectationParser(
 8834                                 new System.Text.Parsing.CharParser('{'))), 
 8835                         new System.Text.Parsing.KleeneStarParser(
 8836                             new System.Text.Parsing.NonterminalParser(ToUtf32("BasicBlock"), ToUtf32("BasicBlock"), 2))), 
 8837                     new System.Text.Parsing.ExpectationParser(
 8838                         new System.Text.Parsing.CharParser('}')))));
 8839             AddRule(new FunctionHeaderRule(ToUtf32("FunctionHeader"), GetScope(), Domain()->GetNextRuleId(), 
 8840                 new System.Text.Parsing.SequenceParser(
 8841                     new System.Text.Parsing.SequenceParser(
 8842                         new System.Text.Parsing.KeywordParser(ToUtf32("function")), 
 8843                         new System.Text.Parsing.ExpectationParser(
 8844                             new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))), 
 8845                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8846                         new System.Text.Parsing.ExpectationParser(
 8847                             new System.Text.Parsing.NonterminalParser(ToUtf32("functionId"), ToUtf32("identifier"), 0))))));
 8848             AddRule(new BasicBlockRule(ToUtf32("BasicBlock"), GetScope(), Domain()->GetNextRuleId(), 
 8849                 new System.Text.Parsing.TokenParser(
 8850                     new System.Text.Parsing.SequenceParser(
 8851                         new System.Text.Parsing.SequenceParser(
 8852                             new System.Text.Parsing.SequenceParser(
 8853                                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8854                                     new System.Text.Parsing.NonterminalParser(ToUtf32("id"), ToUtf32("Label"), 0)), 
 8855                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8856                             new System.Text.Parsing.PositiveParser(
 8857                                 new System.Text.Parsing.NonterminalParser(ToUtf32("InstructionLine"), ToUtf32("InstructionLine"), 2))), 
 8858                         new System.Text.Parsing.OptionalParser(
 8859                             new System.Text.Parsing.NonterminalParser(ToUtf32("EmptyLine"), ToUtf32("EmptyLine"), 0))))));
 8860             AddRule(new System.Text.Parsing.RuleParser(ToUtf32("EmptyLine"), GetScope(), Domain()->GetNextRuleId(), 
 8861                 new System.Text.Parsing.TokenParser(
 8862                     new System.Text.Parsing.SequenceParser(
 8863                         new System.Text.Parsing.OptionalParser(
 8864                             new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8865                         new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0)))));
 8866             AddRule(new InstructionLineRule(ToUtf32("InstructionLine"), GetScope(), Domain()->GetNextRuleId(), 
 8867                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8868                     new System.Text.Parsing.TokenParser(
 8869                         new System.Text.Parsing.SequenceParser(
 8870                             new System.Text.Parsing.SequenceParser(
 8871                                 new System.Text.Parsing.SequenceParser(
 8872                                     new System.Text.Parsing.OptionalParser(
 8873                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8874                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Instruction"), ToUtf32("Instruction"), 1)), 
 8875                                 new System.Text.Parsing.OptionalParser(
 8876                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))), 
 8877                             new System.Text.Parsing.ExpectationParser(
 8878                                 new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0)))))));
 8879             AddRule(new InstructionRule(ToUtf32("Instruction"), GetScope(), Domain()->GetNextRuleId(), 
 8880                 new System.Text.Parsing.AlternativeParser(
 8881                     new System.Text.Parsing.AlternativeParser(
 8882                         new System.Text.Parsing.AlternativeParser(
 8883                             new System.Text.Parsing.AlternativeParser(
 8884                                 new System.Text.Parsing.AlternativeParser(
 8885                                     new System.Text.Parsing.AlternativeParser(
 8886                                         new System.Text.Parsing.AlternativeParser(
 8887                                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8888                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("StoreInstruction"), ToUtf32("StoreInstruction"), 1)), 
 8889                                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 8890                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ArgInstruction"), ToUtf32("ArgInstruction"), 1))), 
 8891                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
 8892                                             new System.Text.Parsing.NonterminalParser(ToUtf32("JumpInstruction"), ToUtf32("JumpInstruction"), 1))), 
 8893                                     new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
 8894                                         new System.Text.Parsing.NonterminalParser(ToUtf32("BranchInstruction"), ToUtf32("BranchInstruction"), 1))), 
 8895                                 new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
 8896                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ProcedureCallInstruction"), ToUtf32("ProcedureCallInstruction"), 1))), 
 8897                             new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
 8898                                 new System.Text.Parsing.NonterminalParser(ToUtf32("RetInstruction"), ToUtf32("RetInstruction"), 1))), 
 8899                         new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
 8900                             new System.Text.Parsing.NonterminalParser(ToUtf32("SwitchInstruction"), ToUtf32("SwitchInstruction"), 1))), 
 8901                     new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
 8902                         new System.Text.Parsing.NonterminalParser(ToUtf32("ValueInstruction"), ToUtf32("ValueInstruction"), 1)))));
 8903             AddRule(new StoreInstructionRule(ToUtf32("StoreInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 8904                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8905                     new System.Text.Parsing.GroupingParser(
 8906                         new System.Text.Parsing.SequenceParser(
 8907                             new System.Text.Parsing.SequenceParser(
 8908                                 new System.Text.Parsing.SequenceParser(
 8909                                     new System.Text.Parsing.SequenceParser(
 8910                                         new System.Text.Parsing.SequenceParser(
 8911                                             new System.Text.Parsing.SequenceParser(
 8912                                                 new System.Text.Parsing.SequenceParser(
 8913                                                     new System.Text.Parsing.SequenceParser(
 8914                                                         new System.Text.Parsing.KeywordParser(ToUtf32("store")), 
 8915                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8916                                                     new System.Text.Parsing.ExpectationParser(
 8917                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))), 
 8918                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8919                                             new System.Text.Parsing.ExpectationParser(
 8920                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2))), 
 8921                                         new System.Text.Parsing.ExpectationParser(
 8922                                             new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 8923                                     new System.Text.Parsing.ExpectationParser(
 8924                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ptrType"), ToUtf32("TypeExpr"), 1))), 
 8925                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8926                             new System.Text.Parsing.ExpectationParser(
 8927                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Value"), 2)))))));
 8928             AddRule(new ArgInstructionRule(ToUtf32("ArgInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 8929                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8930                     new System.Text.Parsing.GroupingParser(
 8931                         new System.Text.Parsing.SequenceParser(
 8932                             new System.Text.Parsing.SequenceParser(
 8933                                 new System.Text.Parsing.SequenceParser(
 8934                                     new System.Text.Parsing.SequenceParser(
 8935                                         new System.Text.Parsing.KeywordParser(ToUtf32("arg")), 
 8936                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8937                                     new System.Text.Parsing.ExpectationParser(
 8938                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))), 
 8939                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8940                             new System.Text.Parsing.ExpectationParser(
 8941                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Value"), 2)))))));
 8942             AddRule(new JumpInstructionRule(ToUtf32("JumpInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 8943                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8944                     new System.Text.Parsing.GroupingParser(
 8945                         new System.Text.Parsing.SequenceParser(
 8946                             new System.Text.Parsing.SequenceParser(
 8947                                 new System.Text.Parsing.KeywordParser(ToUtf32("jmp")), 
 8948                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8949                             new System.Text.Parsing.ExpectationParser(
 8950                                 new System.Text.Parsing.NonterminalParser(ToUtf32("target"), ToUtf32("Label"), 0)))))));
 8951             AddRule(new BranchInstructionRule(ToUtf32("BranchInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 8952                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8953                     new System.Text.Parsing.GroupingParser(
 8954                         new System.Text.Parsing.SequenceParser(
 8955                             new System.Text.Parsing.SequenceParser(
 8956                                 new System.Text.Parsing.SequenceParser(
 8957                                     new System.Text.Parsing.SequenceParser(
 8958                                         new System.Text.Parsing.SequenceParser(
 8959                                             new System.Text.Parsing.SequenceParser(
 8960                                                 new System.Text.Parsing.SequenceParser(
 8961                                                     new System.Text.Parsing.SequenceParser(
 8962                                                         new System.Text.Parsing.KeywordParser(ToUtf32("branch")), 
 8963                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8964                                                     new System.Text.Parsing.ExpectationParser(
 8965                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))), 
 8966                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8967                                             new System.Text.Parsing.ExpectationParser(
 8968                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("cond"), ToUtf32("Value"), 2))), 
 8969                                         new System.Text.Parsing.ExpectationParser(
 8970                                             new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 8971                                     new System.Text.Parsing.ExpectationParser(
 8972                                         new System.Text.Parsing.NonterminalParser(ToUtf32("trueTarget"), ToUtf32("Label"), 0))), 
 8973                                 new System.Text.Parsing.ExpectationParser(
 8974                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 8975                             new System.Text.Parsing.ExpectationParser(
 8976                                 new System.Text.Parsing.NonterminalParser(ToUtf32("falseTarget"), ToUtf32("Label"), 0)))))));
 8977             AddRule(new ProcedureCallInstructionRule(ToUtf32("ProcedureCallInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 8978                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8979                     new System.Text.Parsing.GroupingParser(
 8980                         new System.Text.Parsing.SequenceParser(
 8981                             new System.Text.Parsing.SequenceParser(
 8982                                 new System.Text.Parsing.SequenceParser(
 8983                                     new System.Text.Parsing.SequenceParser(
 8984                                         new System.Text.Parsing.KeywordParser(ToUtf32("call")), 
 8985                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8986                                     new System.Text.Parsing.ExpectationParser(
 8987                                         new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))), 
 8988                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8989                             new System.Text.Parsing.ExpectationParser(
 8990                                 new System.Text.Parsing.NonterminalParser(ToUtf32("callee"), ToUtf32("Value"), 2)))))));
 8991             AddRule(new RetInstructionRule(ToUtf32("RetInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 8992                 new System.Text.Parsing.SequenceParser(
 8993                     new System.Text.Parsing.SequenceParser(
 8994                         new System.Text.Parsing.KeywordParser(ToUtf32("ret")), 
 8995                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 8996                     new System.Text.Parsing.GroupingParser(
 8997                         new System.Text.Parsing.AlternativeParser(
 8998                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 8999                                 new System.Text.Parsing.GroupingParser(
 9000                                     new System.Text.Parsing.DifferenceParser(
 9001                                         new System.Text.Parsing.KeywordParser(ToUtf32("void")), 
 9002                                         new System.Text.Parsing.StringParser(ToUtf32("void*"))))), 
 9003                             new System.Text.Parsing.SequenceParser(
 9004                                 new System.Text.Parsing.SequenceParser(
 9005                                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1), 
 9006                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9007                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9008                                     new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2))))))));
 9009             AddRule(new SwitchInstructionRule(ToUtf32("SwitchInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9010                 new System.Text.Parsing.SequenceParser(
 9011                     new System.Text.Parsing.SequenceParser(
 9012                         new System.Text.Parsing.SequenceParser(
 9013                             new System.Text.Parsing.SequenceParser(
 9014                                 new System.Text.Parsing.SequenceParser(
 9015                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9016                                         new System.Text.Parsing.GroupingParser(
 9017                                             new System.Text.Parsing.SequenceParser(
 9018                                                 new System.Text.Parsing.SequenceParser(
 9019                                                     new System.Text.Parsing.SequenceParser(
 9020                                                         new System.Text.Parsing.SequenceParser(
 9021                                                             new System.Text.Parsing.SequenceParser(
 9022                                                                 new System.Text.Parsing.SequenceParser(
 9023                                                                     new System.Text.Parsing.KeywordParser(ToUtf32("switch")), 
 9024                                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9025                                                                 new System.Text.Parsing.ExpectationParser(
 9026                                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))), 
 9027                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9028                                                         new System.Text.Parsing.ExpectationParser(
 9029                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("cond"), ToUtf32("Value"), 2))), 
 9030                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9031                                                 new System.Text.Parsing.ExpectationParser(
 9032                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("defaultTarget"), ToUtf32("Label"), 0))))), 
 9033                                     new System.Text.Parsing.ExpectationParser(
 9034                                         new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9035                                 new System.Text.Parsing.ExpectationParser(
 9036                                     new System.Text.Parsing.CharParser('['))), 
 9037                             new System.Text.Parsing.OptionalParser(
 9038                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))), 
 9039                         new System.Text.Parsing.ListParser(
 9040                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9041                                 new System.Text.Parsing.GroupingParser(
 9042                                     new System.Text.Parsing.SequenceParser(
 9043                                         new System.Text.Parsing.SequenceParser(
 9044                                             new System.Text.Parsing.SequenceParser(
 9045                                                 new System.Text.Parsing.SequenceParser(
 9046                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("caseType"), ToUtf32("TypeExpr"), 1), 
 9047                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9048                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("caseValue"), ToUtf32("Value"), 2)), 
 9049                                             new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0)), 
 9050                                         new System.Text.Parsing.NonterminalParser(ToUtf32("caseTarget"), ToUtf32("Label"), 0)))), 
 9051                             new System.Text.Parsing.GroupingParser(
 9052                                 new System.Text.Parsing.SequenceParser(
 9053                                     new System.Text.Parsing.SequenceParser(
 9054                                         new System.Text.Parsing.OptionalParser(
 9055                                             new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9056                                         new System.Text.Parsing.CharParser(':')), 
 9057                                     new System.Text.Parsing.OptionalParser(
 9058                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)))))), 
 9059                     new System.Text.Parsing.ExpectationParser(
 9060                         new System.Text.Parsing.CharParser(']')))));
 9061             AddRule(new ValueInstructionRule(ToUtf32("ValueInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9062                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9063                     new System.Text.Parsing.GroupingParser(
 9064                         new System.Text.Parsing.SequenceParser(
 9065                             new System.Text.Parsing.SequenceParser(
 9066                                 new System.Text.Parsing.SequenceParser(
 9067                                     new System.Text.Parsing.SequenceParser(
 9068                                         new System.Text.Parsing.SequenceParser(
 9069                                             new System.Text.Parsing.SequenceParser(
 9070                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1), 
 9071                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9072                                             new System.Text.Parsing.ExpectationParser(
 9073                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("result"), ToUtf32("Value"), 2))), 
 9074                                         new System.Text.Parsing.OptionalParser(
 9075                                             new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))), 
 9076                                     new System.Text.Parsing.CharParser('=')), 
 9077                                 new System.Text.Parsing.OptionalParser(
 9078                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))), 
 9079                             new System.Text.Parsing.ExpectationParser(
 9080                                 new System.Text.Parsing.NonterminalParser(ToUtf32("Operation"), ToUtf32("Operation"), 2)))))));
 9081             AddRule(new OperationRule(ToUtf32("Operation"), GetScope(), Domain()->GetNextRuleId(), 
 9082                 new System.Text.Parsing.AlternativeParser(
 9083                     new System.Text.Parsing.AlternativeParser(
 9084                         new System.Text.Parsing.AlternativeParser(
 9085                             new System.Text.Parsing.AlternativeParser(
 9086                                 new System.Text.Parsing.AlternativeParser(
 9087                                     new System.Text.Parsing.AlternativeParser(
 9088                                         new System.Text.Parsing.AlternativeParser(
 9089                                             new System.Text.Parsing.AlternativeParser(
 9090                                                 new System.Text.Parsing.AlternativeParser(
 9091                                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9092                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("UnaryInstruction"), ToUtf32("UnaryInstruction"), 2)), 
 9093                                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9094                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("BinaryInstruction"), ToUtf32("BinaryInstruction"), 2))), 
 9095                                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
 9096                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ParamInstruction"), ToUtf32("ParamInstruction"), 2))), 
 9097                                             new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
 9098                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("LocalInstruction"), ToUtf32("LocalInstruction"), 2))), 
 9099                                         new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
 9100                                             new System.Text.Parsing.NonterminalParser(ToUtf32("LoadInstruction"), ToUtf32("LoadInstruction"), 2))), 
 9101                                     new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
 9102                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ElemAddrInstruction"), ToUtf32("ElemAddrInstruction"), 2))), 
 9103                                 new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
 9104                                     new System.Text.Parsing.NonterminalParser(ToUtf32("PtrOffsetInstruction"), ToUtf32("PtrOffsetInstruction"), 2))), 
 9105                             new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
 9106                                 new System.Text.Parsing.NonterminalParser(ToUtf32("PtrDiffInstruction"), ToUtf32("PtrDiffInstruction"), 2))), 
 9107                         new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
 9108                             new System.Text.Parsing.NonterminalParser(ToUtf32("FunctionCallInstruction"), ToUtf32("FunctionCallInstruction"), 2))), 
 9109                     new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
 9110                         new System.Text.Parsing.NonterminalParser(ToUtf32("TrapInstruction"), ToUtf32("TrapInstruction"), 2)))));
 9111             AddRule(new UnaryInstructionRule(ToUtf32("UnaryInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9112                 new System.Text.Parsing.AlternativeParser(
 9113                     new System.Text.Parsing.AlternativeParser(
 9114                         new System.Text.Parsing.AlternativeParser(
 9115                             new System.Text.Parsing.AlternativeParser(
 9116                                 new System.Text.Parsing.AlternativeParser(
 9117                                     new System.Text.Parsing.AlternativeParser(
 9118                                         new System.Text.Parsing.AlternativeParser(
 9119                                             new System.Text.Parsing.AlternativeParser(
 9120                                                 new System.Text.Parsing.AlternativeParser(
 9121                                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9122                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("NotInstruction"), ToUtf32("NotInstruction"), 2)), 
 9123                                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9124                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("NegInstruction"), ToUtf32("NegInstruction"), 2))), 
 9125                                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
 9126                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("SignExtendInstruction"), ToUtf32("SignExtendInstruction"), 2))), 
 9127                                             new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
 9128                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ZeroExtendInstruction"), ToUtf32("ZeroExtendInstruction"), 2))), 
 9129                                         new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
 9130                                             new System.Text.Parsing.NonterminalParser(ToUtf32("TruncateInstruction"), ToUtf32("TruncateInstruction"), 2))), 
 9131                                     new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
 9132                                         new System.Text.Parsing.NonterminalParser(ToUtf32("BitCastInstruction"), ToUtf32("BitCastInstruction"), 2))), 
 9133                                 new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
 9134                                     new System.Text.Parsing.NonterminalParser(ToUtf32("IntToFloatInstruction"), ToUtf32("IntToFloatInstruction"), 2))), 
 9135                             new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
 9136                                 new System.Text.Parsing.NonterminalParser(ToUtf32("FloatToIntInstruction"), ToUtf32("FloatToIntInstruction"), 2))), 
 9137                         new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
 9138                             new System.Text.Parsing.NonterminalParser(ToUtf32("IntToPtrInstruction"), ToUtf32("IntToPtrInstruction"), 2))), 
 9139                     new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
 9140                         new System.Text.Parsing.NonterminalParser(ToUtf32("PtrToIntInstruction"), ToUtf32("PtrToIntInstruction"), 2)))));
 9141             AddRule(new NotInstructionRule(ToUtf32("NotInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9142                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9143                     new System.Text.Parsing.GroupingParser(
 9144                         new System.Text.Parsing.SequenceParser(
 9145                             new System.Text.Parsing.SequenceParser(
 9146                                 new System.Text.Parsing.KeywordParser(ToUtf32("not")), 
 9147                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9148                             new System.Text.Parsing.ExpectationParser(
 9149                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
 9150             AddRule(new NegInstructionRule(ToUtf32("NegInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9151                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9152                     new System.Text.Parsing.GroupingParser(
 9153                         new System.Text.Parsing.SequenceParser(
 9154                             new System.Text.Parsing.SequenceParser(
 9155                                 new System.Text.Parsing.KeywordParser(ToUtf32("neg")), 
 9156                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9157                             new System.Text.Parsing.ExpectationParser(
 9158                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
 9159             AddRule(new SignExtendInstructionRule(ToUtf32("SignExtendInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9160                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9161                     new System.Text.Parsing.GroupingParser(
 9162                         new System.Text.Parsing.SequenceParser(
 9163                             new System.Text.Parsing.SequenceParser(
 9164                                 new System.Text.Parsing.KeywordParser(ToUtf32("signextend")), 
 9165                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9166                             new System.Text.Parsing.ExpectationParser(
 9167                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
 9168             AddRule(new ZeroExtendInstructionRule(ToUtf32("ZeroExtendInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9169                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9170                     new System.Text.Parsing.GroupingParser(
 9171                         new System.Text.Parsing.SequenceParser(
 9172                             new System.Text.Parsing.SequenceParser(
 9173                                 new System.Text.Parsing.KeywordParser(ToUtf32("zeroextend")), 
 9174                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9175                             new System.Text.Parsing.ExpectationParser(
 9176                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
 9177             AddRule(new TruncateInstructionRule(ToUtf32("TruncateInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9178                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9179                     new System.Text.Parsing.GroupingParser(
 9180                         new System.Text.Parsing.SequenceParser(
 9181                             new System.Text.Parsing.SequenceParser(
 9182                                 new System.Text.Parsing.KeywordParser(ToUtf32("truncate")), 
 9183                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9184                             new System.Text.Parsing.ExpectationParser(
 9185                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
 9186             AddRule(new BitCastInstructionRule(ToUtf32("BitCastInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9187                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9188                     new System.Text.Parsing.GroupingParser(
 9189                         new System.Text.Parsing.SequenceParser(
 9190                             new System.Text.Parsing.SequenceParser(
 9191                                 new System.Text.Parsing.KeywordParser(ToUtf32("bitcast")), 
 9192                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9193                             new System.Text.Parsing.ExpectationParser(
 9194                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
 9195             AddRule(new IntToFloatInstructionRule(ToUtf32("IntToFloatInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9196                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9197                     new System.Text.Parsing.GroupingParser(
 9198                         new System.Text.Parsing.SequenceParser(
 9199                             new System.Text.Parsing.SequenceParser(
 9200                                 new System.Text.Parsing.KeywordParser(ToUtf32("inttofloat")), 
 9201                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9202                             new System.Text.Parsing.ExpectationParser(
 9203                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
 9204             AddRule(new FloatToIntInstructionRule(ToUtf32("FloatToIntInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9205                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9206                     new System.Text.Parsing.GroupingParser(
 9207                         new System.Text.Parsing.SequenceParser(
 9208                             new System.Text.Parsing.SequenceParser(
 9209                                 new System.Text.Parsing.KeywordParser(ToUtf32("floattoint")), 
 9210                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9211                             new System.Text.Parsing.ExpectationParser(
 9212                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
 9213             AddRule(new IntToPtrInstructionRule(ToUtf32("IntToPtrInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9214                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9215                     new System.Text.Parsing.GroupingParser(
 9216                         new System.Text.Parsing.SequenceParser(
 9217                             new System.Text.Parsing.SequenceParser(
 9218                                 new System.Text.Parsing.KeywordParser(ToUtf32("inttoptr")), 
 9219                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9220                             new System.Text.Parsing.ExpectationParser(
 9221                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
 9222             AddRule(new PtrToIntInstructionRule(ToUtf32("PtrToIntInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9223                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9224                     new System.Text.Parsing.GroupingParser(
 9225                         new System.Text.Parsing.SequenceParser(
 9226                             new System.Text.Parsing.SequenceParser(
 9227                                 new System.Text.Parsing.KeywordParser(ToUtf32("ptrtoint")), 
 9228                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9229                             new System.Text.Parsing.ExpectationParser(
 9230                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
 9231             AddRule(new BinaryInstructionRule(ToUtf32("BinaryInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9232                 new System.Text.Parsing.AlternativeParser(
 9233                     new System.Text.Parsing.AlternativeParser(
 9234                         new System.Text.Parsing.AlternativeParser(
 9235                             new System.Text.Parsing.AlternativeParser(
 9236                                 new System.Text.Parsing.AlternativeParser(
 9237                                     new System.Text.Parsing.AlternativeParser(
 9238                                         new System.Text.Parsing.AlternativeParser(
 9239                                             new System.Text.Parsing.AlternativeParser(
 9240                                                 new System.Text.Parsing.AlternativeParser(
 9241                                                     new System.Text.Parsing.AlternativeParser(
 9242                                                         new System.Text.Parsing.AlternativeParser(
 9243                                                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9244                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("AddInstruction"), ToUtf32("AddInstruction"), 2)), 
 9245                                                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9246                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("SubInstruction"), ToUtf32("SubInstruction"), 2))), 
 9247                                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
 9248                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("MulInstruction"), ToUtf32("MulInstruction"), 2))), 
 9249                                                     new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
 9250                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("DivInstruction"), ToUtf32("DivInstruction"), 2))), 
 9251                                                 new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
 9252                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ModInstruction"), ToUtf32("ModInstruction"), 2))), 
 9253                                             new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
 9254                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("AndInstruction"), ToUtf32("AndInstruction"), 2))), 
 9255                                         new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
 9256                                             new System.Text.Parsing.NonterminalParser(ToUtf32("OrInstruction"), ToUtf32("OrInstruction"), 2))), 
 9257                                     new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
 9258                                         new System.Text.Parsing.NonterminalParser(ToUtf32("XorInstruction"), ToUtf32("XorInstruction"), 2))), 
 9259                                 new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
 9260                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ShlInstruction"), ToUtf32("ShlInstruction"), 2))), 
 9261                             new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
 9262                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ShrInstruction"), ToUtf32("ShrInstruction"), 2))), 
 9263                         new System.Text.Parsing.ActionParser(ToUtf32("A10"), 
 9264                             new System.Text.Parsing.NonterminalParser(ToUtf32("EqualInstruction"), ToUtf32("EqualInstruction"), 2))), 
 9265                     new System.Text.Parsing.ActionParser(ToUtf32("A11"), 
 9266                         new System.Text.Parsing.NonterminalParser(ToUtf32("LessInstruction"), ToUtf32("LessInstruction"), 2)))));
 9267             AddRule(new AddInstructionRule(ToUtf32("AddInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9268                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9269                     new System.Text.Parsing.GroupingParser(
 9270                         new System.Text.Parsing.SequenceParser(
 9271                             new System.Text.Parsing.SequenceParser(
 9272                                 new System.Text.Parsing.SequenceParser(
 9273                                     new System.Text.Parsing.SequenceParser(
 9274                                         new System.Text.Parsing.KeywordParser(ToUtf32("add")), 
 9275                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9276                                     new System.Text.Parsing.ExpectationParser(
 9277                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9278                                 new System.Text.Parsing.ExpectationParser(
 9279                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9280                             new System.Text.Parsing.ExpectationParser(
 9281                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9282             AddRule(new SubInstructionRule(ToUtf32("SubInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9283                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9284                     new System.Text.Parsing.GroupingParser(
 9285                         new System.Text.Parsing.SequenceParser(
 9286                             new System.Text.Parsing.SequenceParser(
 9287                                 new System.Text.Parsing.SequenceParser(
 9288                                     new System.Text.Parsing.SequenceParser(
 9289                                         new System.Text.Parsing.KeywordParser(ToUtf32("sub")), 
 9290                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9291                                     new System.Text.Parsing.ExpectationParser(
 9292                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9293                                 new System.Text.Parsing.ExpectationParser(
 9294                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9295                             new System.Text.Parsing.ExpectationParser(
 9296                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9297             AddRule(new MulInstructionRule(ToUtf32("MulInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9298                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9299                     new System.Text.Parsing.GroupingParser(
 9300                         new System.Text.Parsing.SequenceParser(
 9301                             new System.Text.Parsing.SequenceParser(
 9302                                 new System.Text.Parsing.SequenceParser(
 9303                                     new System.Text.Parsing.SequenceParser(
 9304                                         new System.Text.Parsing.KeywordParser(ToUtf32("mul")), 
 9305                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9306                                     new System.Text.Parsing.ExpectationParser(
 9307                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9308                                 new System.Text.Parsing.ExpectationParser(
 9309                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9310                             new System.Text.Parsing.ExpectationParser(
 9311                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9312             AddRule(new DivInstructionRule(ToUtf32("DivInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9313                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9314                     new System.Text.Parsing.GroupingParser(
 9315                         new System.Text.Parsing.SequenceParser(
 9316                             new System.Text.Parsing.SequenceParser(
 9317                                 new System.Text.Parsing.SequenceParser(
 9318                                     new System.Text.Parsing.SequenceParser(
 9319                                         new System.Text.Parsing.KeywordParser(ToUtf32("div")), 
 9320                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9321                                     new System.Text.Parsing.ExpectationParser(
 9322                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9323                                 new System.Text.Parsing.ExpectationParser(
 9324                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9325                             new System.Text.Parsing.ExpectationParser(
 9326                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9327             AddRule(new ModInstructionRule(ToUtf32("ModInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9328                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9329                     new System.Text.Parsing.GroupingParser(
 9330                         new System.Text.Parsing.SequenceParser(
 9331                             new System.Text.Parsing.SequenceParser(
 9332                                 new System.Text.Parsing.SequenceParser(
 9333                                     new System.Text.Parsing.SequenceParser(
 9334                                         new System.Text.Parsing.KeywordParser(ToUtf32("mod")), 
 9335                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9336                                     new System.Text.Parsing.ExpectationParser(
 9337                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9338                                 new System.Text.Parsing.ExpectationParser(
 9339                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9340                             new System.Text.Parsing.ExpectationParser(
 9341                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9342             AddRule(new AndInstructionRule(ToUtf32("AndInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9343                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9344                     new System.Text.Parsing.GroupingParser(
 9345                         new System.Text.Parsing.SequenceParser(
 9346                             new System.Text.Parsing.SequenceParser(
 9347                                 new System.Text.Parsing.SequenceParser(
 9348                                     new System.Text.Parsing.SequenceParser(
 9349                                         new System.Text.Parsing.KeywordParser(ToUtf32("and")), 
 9350                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9351                                     new System.Text.Parsing.ExpectationParser(
 9352                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9353                                 new System.Text.Parsing.ExpectationParser(
 9354                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9355                             new System.Text.Parsing.ExpectationParser(
 9356                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9357             AddRule(new OrInstructionRule(ToUtf32("OrInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9358                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9359                     new System.Text.Parsing.GroupingParser(
 9360                         new System.Text.Parsing.SequenceParser(
 9361                             new System.Text.Parsing.SequenceParser(
 9362                                 new System.Text.Parsing.SequenceParser(
 9363                                     new System.Text.Parsing.SequenceParser(
 9364                                         new System.Text.Parsing.KeywordParser(ToUtf32("or")), 
 9365                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9366                                     new System.Text.Parsing.ExpectationParser(
 9367                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9368                                 new System.Text.Parsing.ExpectationParser(
 9369                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9370                             new System.Text.Parsing.ExpectationParser(
 9371                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9372             AddRule(new XorInstructionRule(ToUtf32("XorInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9373                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9374                     new System.Text.Parsing.GroupingParser(
 9375                         new System.Text.Parsing.SequenceParser(
 9376                             new System.Text.Parsing.SequenceParser(
 9377                                 new System.Text.Parsing.SequenceParser(
 9378                                     new System.Text.Parsing.SequenceParser(
 9379                                         new System.Text.Parsing.KeywordParser(ToUtf32("xor")), 
 9380                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9381                                     new System.Text.Parsing.ExpectationParser(
 9382                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9383                                 new System.Text.Parsing.ExpectationParser(
 9384                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9385                             new System.Text.Parsing.ExpectationParser(
 9386                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9387             AddRule(new ShlInstructionRule(ToUtf32("ShlInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9388                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9389                     new System.Text.Parsing.GroupingParser(
 9390                         new System.Text.Parsing.SequenceParser(
 9391                             new System.Text.Parsing.SequenceParser(
 9392                                 new System.Text.Parsing.SequenceParser(
 9393                                     new System.Text.Parsing.SequenceParser(
 9394                                         new System.Text.Parsing.KeywordParser(ToUtf32("shl")), 
 9395                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9396                                     new System.Text.Parsing.ExpectationParser(
 9397                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9398                                 new System.Text.Parsing.ExpectationParser(
 9399                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9400                             new System.Text.Parsing.ExpectationParser(
 9401                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9402             AddRule(new ShrInstructionRule(ToUtf32("ShrInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9403                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9404                     new System.Text.Parsing.GroupingParser(
 9405                         new System.Text.Parsing.SequenceParser(
 9406                             new System.Text.Parsing.SequenceParser(
 9407                                 new System.Text.Parsing.SequenceParser(
 9408                                     new System.Text.Parsing.SequenceParser(
 9409                                         new System.Text.Parsing.KeywordParser(ToUtf32("shr")), 
 9410                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9411                                     new System.Text.Parsing.ExpectationParser(
 9412                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9413                                 new System.Text.Parsing.ExpectationParser(
 9414                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9415                             new System.Text.Parsing.ExpectationParser(
 9416                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9417             AddRule(new EqualInstructionRule(ToUtf32("EqualInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9418                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9419                     new System.Text.Parsing.GroupingParser(
 9420                         new System.Text.Parsing.SequenceParser(
 9421                             new System.Text.Parsing.SequenceParser(
 9422                                 new System.Text.Parsing.SequenceParser(
 9423                                     new System.Text.Parsing.SequenceParser(
 9424                                         new System.Text.Parsing.KeywordParser(ToUtf32("equal")), 
 9425                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9426                                     new System.Text.Parsing.ExpectationParser(
 9427                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9428                                 new System.Text.Parsing.ExpectationParser(
 9429                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9430                             new System.Text.Parsing.ExpectationParser(
 9431                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9432             AddRule(new LessInstructionRule(ToUtf32("LessInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9433                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9434                     new System.Text.Parsing.GroupingParser(
 9435                         new System.Text.Parsing.SequenceParser(
 9436                             new System.Text.Parsing.SequenceParser(
 9437                                 new System.Text.Parsing.SequenceParser(
 9438                                     new System.Text.Parsing.SequenceParser(
 9439                                         new System.Text.Parsing.KeywordParser(ToUtf32("less")), 
 9440                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9441                                     new System.Text.Parsing.ExpectationParser(
 9442                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
 9443                                 new System.Text.Parsing.ExpectationParser(
 9444                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9445                             new System.Text.Parsing.ExpectationParser(
 9446                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
 9447             AddRule(new ParamInstructionRule(ToUtf32("ParamInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9448                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9449                     new System.Text.Parsing.KeywordParser(ToUtf32("param")))));
 9450             AddRule(new LocalInstructionRule(ToUtf32("LocalInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9451                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9452                     new System.Text.Parsing.GroupingParser(
 9453                         new System.Text.Parsing.SequenceParser(
 9454                             new System.Text.Parsing.SequenceParser(
 9455                                 new System.Text.Parsing.KeywordParser(ToUtf32("local")), 
 9456                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9457                             new System.Text.Parsing.ExpectationParser(
 9458                                 new System.Text.Parsing.NonterminalParser(ToUtf32("localType"), ToUtf32("TypeExpr"), 1)))))));
 9459             AddRule(new LoadInstructionRule(ToUtf32("LoadInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9460                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9461                     new System.Text.Parsing.GroupingParser(
 9462                         new System.Text.Parsing.SequenceParser(
 9463                             new System.Text.Parsing.SequenceParser(
 9464                                 new System.Text.Parsing.KeywordParser(ToUtf32("load")), 
 9465                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9466                             new System.Text.Parsing.ExpectationParser(
 9467                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1)))))));
 9468             AddRule(new ElemAddrInstructionRule(ToUtf32("ElemAddrInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9469                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9470                     new System.Text.Parsing.GroupingParser(
 9471                         new System.Text.Parsing.SequenceParser(
 9472                             new System.Text.Parsing.SequenceParser(
 9473                                 new System.Text.Parsing.SequenceParser(
 9474                                     new System.Text.Parsing.SequenceParser(
 9475                                         new System.Text.Parsing.KeywordParser(ToUtf32("elemaddr")), 
 9476                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9477                                     new System.Text.Parsing.ExpectationParser(
 9478                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1))), 
 9479                                 new System.Text.Parsing.ExpectationParser(
 9480                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9481                             new System.Text.Parsing.ExpectationParser(
 9482                                 new System.Text.Parsing.NonterminalParser(ToUtf32("index"), ToUtf32("Operand"), 1)))))));
 9483             AddRule(new PtrOffsetInstructionRule(ToUtf32("PtrOffsetInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9484                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9485                     new System.Text.Parsing.GroupingParser(
 9486                         new System.Text.Parsing.SequenceParser(
 9487                             new System.Text.Parsing.SequenceParser(
 9488                                 new System.Text.Parsing.SequenceParser(
 9489                                     new System.Text.Parsing.SequenceParser(
 9490                                         new System.Text.Parsing.KeywordParser(ToUtf32("ptroffset")), 
 9491                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9492                                     new System.Text.Parsing.ExpectationParser(
 9493                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1))), 
 9494                                 new System.Text.Parsing.ExpectationParser(
 9495                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9496                             new System.Text.Parsing.ExpectationParser(
 9497                                 new System.Text.Parsing.NonterminalParser(ToUtf32("offset"), ToUtf32("Operand"), 1)))))));
 9498             AddRule(new PtrDiffInstructionRule(ToUtf32("PtrDiffInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9499                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9500                     new System.Text.Parsing.GroupingParser(
 9501                         new System.Text.Parsing.SequenceParser(
 9502                             new System.Text.Parsing.SequenceParser(
 9503                                 new System.Text.Parsing.SequenceParser(
 9504                                     new System.Text.Parsing.SequenceParser(
 9505                                         new System.Text.Parsing.KeywordParser(ToUtf32("ptrdiff")), 
 9506                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9507                                     new System.Text.Parsing.ExpectationParser(
 9508                                         new System.Text.Parsing.NonterminalParser(ToUtf32("leftPtr"), ToUtf32("Operand"), 1))), 
 9509                                 new System.Text.Parsing.ExpectationParser(
 9510                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9511                             new System.Text.Parsing.ExpectationParser(
 9512                                 new System.Text.Parsing.NonterminalParser(ToUtf32("rightPtr"), ToUtf32("Operand"), 1)))))));
 9513             AddRule(new FunctionCallInstructionRule(ToUtf32("FunctionCallInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9514                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9515                     new System.Text.Parsing.GroupingParser(
 9516                         new System.Text.Parsing.SequenceParser(
 9517                             new System.Text.Parsing.SequenceParser(
 9518                                 new System.Text.Parsing.SequenceParser(
 9519                                     new System.Text.Parsing.SequenceParser(
 9520                                         new System.Text.Parsing.KeywordParser(ToUtf32("call")), 
 9521                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9522                                     new System.Text.Parsing.ExpectationParser(
 9523                                         new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))), 
 9524                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9525                             new System.Text.Parsing.ExpectationParser(
 9526                                 new System.Text.Parsing.NonterminalParser(ToUtf32("callee"), ToUtf32("Value"), 2)))))));
 9527             AddRule(new TrapInstructionRule(ToUtf32("TrapInstruction"), GetScope(), Domain()->GetNextRuleId(), 
 9528                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9529                     new System.Text.Parsing.GroupingParser(
 9530                         new System.Text.Parsing.SequenceParser(
 9531                             new System.Text.Parsing.SequenceParser(
 9532                                 new System.Text.Parsing.SequenceParser(
 9533                                     new System.Text.Parsing.SequenceParser(
 9534                                         new System.Text.Parsing.SequenceParser(
 9535                                             new System.Text.Parsing.SequenceParser(
 9536                                                 new System.Text.Parsing.SequenceParser(
 9537                                                     new System.Text.Parsing.SequenceParser(
 9538                                                         new System.Text.Parsing.SequenceParser(
 9539                                                             new System.Text.Parsing.SequenceParser(
 9540                                                                 new System.Text.Parsing.SequenceParser(
 9541                                                                     new System.Text.Parsing.SequenceParser(
 9542                                                                         new System.Text.Parsing.KeywordParser(ToUtf32("trap")), 
 9543                                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9544                                                                     new System.Text.Parsing.ExpectationParser(
 9545                                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type1"), ToUtf32("TypeExpr"), 1))), 
 9546                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9547                                                             new System.Text.Parsing.ExpectationParser(
 9548                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("val1"), ToUtf32("Value"), 2))), 
 9549                                                         new System.Text.Parsing.ExpectationParser(
 9550                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9551                                                     new System.Text.Parsing.ExpectationParser(
 9552                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type2"), ToUtf32("TypeExpr"), 1))), 
 9553                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9554                                             new System.Text.Parsing.ExpectationParser(
 9555                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("val2"), ToUtf32("Value"), 2))), 
 9556                                         new System.Text.Parsing.ExpectationParser(
 9557                                             new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
 9558                                     new System.Text.Parsing.ExpectationParser(
 9559                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type3"), ToUtf32("TypeExpr"), 1))), 
 9560                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9561                             new System.Text.Parsing.ExpectationParser(
 9562                                 new System.Text.Parsing.NonterminalParser(ToUtf32("val3"), ToUtf32("Value"), 2)))))));
 9563             AddRule(new OperandRule(ToUtf32("Operand"), GetScope(), Domain()->GetNextRuleId(), 
 9564                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9565                     new System.Text.Parsing.GroupingParser(
 9566                         new System.Text.Parsing.SequenceParser(
 9567                             new System.Text.Parsing.SequenceParser(
 9568                                 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1), 
 9569                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9570                             new System.Text.Parsing.ExpectationParser(
 9571                                 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2)))))));
 9572             AddRule(new LabelRule(ToUtf32("Label"), GetScope(), Domain()->GetNextRuleId(), 
 9573                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9574                     new System.Text.Parsing.TokenParser(
 9575                         new System.Text.Parsing.SequenceParser(
 9576                             new System.Text.Parsing.CharParser('@'), 
 9577                             new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))))));
 9578             AddRule(new ValueRule(ToUtf32("Value"), GetScope(), Domain()->GetNextRuleId(), 
 9579                 new System.Text.Parsing.AlternativeParser(
 9580                     new System.Text.Parsing.AlternativeParser(
 9581                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9582                             new System.Text.Parsing.NonterminalParser(ToUtf32("IdValue"), ToUtf32("IdValue"), 2)), 
 9583                         new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9584                             new System.Text.Parsing.NonterminalParser(ToUtf32("SymbolValue"), ToUtf32("SymbolValue"), 2))), 
 9585                     new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
 9586                         new System.Text.Parsing.NonterminalParser(ToUtf32("LiteralValue"), ToUtf32("LiteralValue"), 2)))));
 9587             AddRule(new IdValueRule(ToUtf32("IdValue"), GetScope(), Domain()->GetNextRuleId(), 
 9588                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9589                     new System.Text.Parsing.GroupingParser(
 9590                         new System.Text.Parsing.SequenceParser(
 9591                             new System.Text.Parsing.CharParser('$'), 
 9592                             new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))))));
 9593             AddRule(new SymbolValueRule(ToUtf32("SymbolValue"), GetScope(), Domain()->GetNextRuleId(), 
 9594                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9595                     new System.Text.Parsing.TokenParser(
 9596                         new System.Text.Parsing.SequenceParser(
 9597                             new System.Text.Parsing.CharParser('@'), 
 9598                             new System.Text.Parsing.NonterminalParser(ToUtf32("identifier"), ToUtf32("identifier"), 0))))));
 9599             AddRule(new LiteralValueRule(ToUtf32("LiteralValue"), GetScope(), Domain()->GetNextRuleId(), 
 9600                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9601                     new System.Text.Parsing.GroupingParser(
 9602                         new System.Text.Parsing.PositiveParser(
 9603                             new System.Text.Parsing.TokenParser(
 9604                                 new System.Text.Parsing.DifferenceParser(
 9605                                     new System.Text.Parsing.AnyCharParser(), 
 9606                                     new System.Text.Parsing.GroupingParser(
 9607                                         new System.Text.Parsing.AlternativeParser(
 9608                                             new System.Text.Parsing.AlternativeParser(
 9609                                                 new System.Text.Parsing.CharParser(','), 
 9610                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9611                                             new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0))))))))));
 9612             AddRule(new System.Text.Parsing.RuleParser(ToUtf32("S"), GetScope(), Domain()->GetNextRuleId(), 
 9613                 new System.Text.Parsing.PositiveParser(
 9614                     new System.Text.Parsing.CharSetParser(ToUtf32(" \t")))));
 9615             AddRule(new System.Text.Parsing.RuleParser(ToUtf32("Comma"), GetScope(), Domain()->GetNextRuleId(), 
 9616                 new System.Text.Parsing.SequenceParser(
 9617                     new System.Text.Parsing.SequenceParser(
 9618                         new System.Text.Parsing.OptionalParser(
 9619                             new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
 9620                         new System.Text.Parsing.CharParser(',')), 
 9621                     new System.Text.Parsing.OptionalParser(
 9622                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)))));
 9623             AddRule(new TypeDeclarationRule(ToUtf32("TypeDeclaration"), GetScope(), Domain()->GetNextRuleId(), 
 9624                 new System.Text.Parsing.SequenceParser(
 9625                     new System.Text.Parsing.SequenceParser(
 9626                         new System.Text.Parsing.SequenceParser(
 9627                             new System.Text.Parsing.NonterminalParser(ToUtf32("typeId"), ToUtf32("StrTypeId"), 1), 
 9628                             new System.Text.Parsing.ExpectationParser(
 9629                                 new System.Text.Parsing.CharParser('='))), 
 9630                         new System.Text.Parsing.ExpectationParser(
 9631                             new System.Text.Parsing.KeywordParser(ToUtf32("type")))), 
 9632                     new System.Text.Parsing.GroupingParser(
 9633                         new System.Text.Parsing.AlternativeParser(
 9634                             new System.Text.Parsing.AlternativeParser(
 9635                                 new System.Text.Parsing.NonterminalParser(ToUtf32("StructureType"), ToUtf32("StructureType"), 2), 
 9636                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ArrayType"), ToUtf32("ArrayType"), 2)), 
 9637                             new System.Text.Parsing.NonterminalParser(ToUtf32("FunctionType"), ToUtf32("FunctionType"), 2))))));
 9638             AddRule(new StructureTypeRule(ToUtf32("StructureType"), GetScope(), Domain()->GetNextRuleId(), 
 9639                 new System.Text.Parsing.SequenceParser(
 9640                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9641                         new System.Text.Parsing.GroupingParser(
 9642                             new System.Text.Parsing.SequenceParser(
 9643                                 new System.Text.Parsing.SequenceParser(
 9644                                     new System.Text.Parsing.CharParser('{'), 
 9645                                     new System.Text.Parsing.OptionalParser(
 9646                                         new System.Text.Parsing.GroupingParser(
 9647                                             new System.Text.Parsing.ListParser(
 9648                                                 new System.Text.Parsing.GroupingParser(
 9649                                                     new System.Text.Parsing.SequenceParser(
 9650                                                         new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9651                                                             new System.Text.Parsing.ExpectationParser(
 9652                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("StrTypeId"), ToUtf32("StrTypeId"), 1))), 
 9653                                                         new System.Text.Parsing.OptionalParser(
 9654                                                             new System.Text.Parsing.GroupingParser(
 9655                                                                 new System.Text.Parsing.SequenceParser(
 9656                                                                     new System.Text.Parsing.SequenceParser(
 9657                                                                         new System.Text.Parsing.SequenceParser(
 9658                                                                             new System.Text.Parsing.CharParser(':'), 
 9659                                                                             new System.Text.Parsing.StringParser(ToUtf32("offset"))), 
 9660                                                                         new System.Text.Parsing.CharParser('=')), 
 9661                                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("long"), ToUtf32("long"), 0)))))), 
 9662                                                 new System.Text.Parsing.CharParser(','))))), 
 9663                                 new System.Text.Parsing.ExpectationParser(
 9664                                     new System.Text.Parsing.CharParser('}'))))), 
 9665                     new System.Text.Parsing.OptionalParser(
 9666                         new System.Text.Parsing.GroupingParser(
 9667                             new System.Text.Parsing.SequenceParser(
 9668                                 new System.Text.Parsing.SequenceParser(
 9669                                     new System.Text.Parsing.SequenceParser(
 9670                                         new System.Text.Parsing.SequenceParser(
 9671                                             new System.Text.Parsing.SequenceParser(
 9672                                                 new System.Text.Parsing.SequenceParser(
 9673                                                     new System.Text.Parsing.KeywordParser(ToUtf32("size")), 
 9674                                                     new System.Text.Parsing.CharParser('=')), 
 9675                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("sz"), ToUtf32("long"), 0)), 
 9676                                             new System.Text.Parsing.CharParser(',')), 
 9677                                         new System.Text.Parsing.KeywordParser(ToUtf32("alignment"))), 
 9678                                     new System.Text.Parsing.CharParser('=')), 
 9679                                 new System.Text.Parsing.NonterminalParser(ToUtf32("al"), ToUtf32("long"), 0)))))));
 9680             AddRule(new ArrayTypeRule(ToUtf32("ArrayType"), GetScope(), Domain()->GetNextRuleId(), 
 9681                 new System.Text.Parsing.SequenceParser(
 9682                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9683                         new System.Text.Parsing.GroupingParser(
 9684                             new System.Text.Parsing.SequenceParser(
 9685                                 new System.Text.Parsing.SequenceParser(
 9686                                     new System.Text.Parsing.SequenceParser(
 9687                                         new System.Text.Parsing.SequenceParser(
 9688                                             new System.Text.Parsing.CharParser('['), 
 9689                                             new System.Text.Parsing.ExpectationParser(
 9690                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("size"), ToUtf32("long"), 0))), 
 9691                                         new System.Text.Parsing.ExpectationParser(
 9692                                             new System.Text.Parsing.CharParser('x'))), 
 9693                                     new System.Text.Parsing.ExpectationParser(
 9694                                         new System.Text.Parsing.NonterminalParser(ToUtf32("elementTypeId"), ToUtf32("StrTypeId"), 1))), 
 9695                                 new System.Text.Parsing.ExpectationParser(
 9696                                     new System.Text.Parsing.CharParser(']'))))), 
 9697                     new System.Text.Parsing.OptionalParser(
 9698                         new System.Text.Parsing.GroupingParser(
 9699                             new System.Text.Parsing.SequenceParser(
 9700                                 new System.Text.Parsing.SequenceParser(
 9701                                     new System.Text.Parsing.SequenceParser(
 9702                                         new System.Text.Parsing.SequenceParser(
 9703                                             new System.Text.Parsing.SequenceParser(
 9704                                                 new System.Text.Parsing.SequenceParser(
 9705                                                     new System.Text.Parsing.KeywordParser(ToUtf32("size")), 
 9706                                                     new System.Text.Parsing.CharParser('=')), 
 9707                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("sz"), ToUtf32("long"), 0)), 
 9708                                             new System.Text.Parsing.CharParser(',')), 
 9709                                         new System.Text.Parsing.KeywordParser(ToUtf32("alignment"))), 
 9710                                     new System.Text.Parsing.CharParser('=')), 
 9711                                 new System.Text.Parsing.NonterminalParser(ToUtf32("al"), ToUtf32("long"), 0)))))));
 9712             AddRule(new FunctionTypeRule(ToUtf32("FunctionType"), GetScope(), Domain()->GetNextRuleId(), 
 9713                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9714                     new System.Text.Parsing.GroupingParser(
 9715                         new System.Text.Parsing.SequenceParser(
 9716                             new System.Text.Parsing.SequenceParser(
 9717                                 new System.Text.Parsing.SequenceParser(
 9718                                     new System.Text.Parsing.SequenceParser(
 9719                                         new System.Text.Parsing.KeywordParser(ToUtf32("function")), 
 9720                                         new System.Text.Parsing.ExpectationParser(
 9721                                             new System.Text.Parsing.NonterminalParser(ToUtf32("returnTypeId"), ToUtf32("StrTypeId"), 1))), 
 9722                                     new System.Text.Parsing.ExpectationParser(
 9723                                         new System.Text.Parsing.CharParser('('))), 
 9724                                 new System.Text.Parsing.OptionalParser(
 9725                                     new System.Text.Parsing.GroupingParser(
 9726                                         new System.Text.Parsing.ListParser(
 9727                                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9728                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("paramType"), ToUtf32("StrTypeId"), 1)), 
 9729                                             new System.Text.Parsing.CharParser(','))))), 
 9730                             new System.Text.Parsing.ExpectationParser(
 9731                                 new System.Text.Parsing.CharParser(')')))))));
 9732             AddRule(new StrTypeIdRule(ToUtf32("StrTypeId"), GetScope(), Domain()->GetNextRuleId(), 
 9733                 new System.Text.Parsing.SequenceParser(
 9734                     new System.Text.Parsing.GroupingParser(
 9735                         new System.Text.Parsing.AlternativeParser(
 9736                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9737                                 new System.Text.Parsing.TokenParser(
 9738                                     new System.Text.Parsing.SequenceParser(
 9739                                         new System.Text.Parsing.StringParser(ToUtf32("$T")), 
 9740                                         new System.Text.Parsing.NonterminalParser(ToUtf32("uint"), ToUtf32("uint"), 0)))), 
 9741                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9742                                 new System.Text.Parsing.GroupingParser(
 9743                                     new System.Text.Parsing.KeywordListParser(ToUtf32("identifier"), keywords0))))), 
 9744                     new System.Text.Parsing.KleeneStarParser(
 9745                         new System.Text.Parsing.GroupingParser(
 9746                             new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
 9747                                 new System.Text.Parsing.GroupingParser(
 9748                                     new System.Text.Parsing.CharParser('*'))))))));
 9749             AddRule(new TypeExprRule(ToUtf32("TypeExpr"), GetScope(), Domain()->GetNextRuleId(), 
 9750                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9751                     new System.Text.Parsing.NonterminalParser(ToUtf32("PostfixTypeExpr"), ToUtf32("PostfixTypeExpr"), 1))));
 9752             AddRule(new PostfixTypeExprRule(ToUtf32("PostfixTypeExpr"), GetScope(), Domain()->GetNextRuleId(), 
 9753                 new System.Text.Parsing.SequenceParser(
 9754                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9755                         new System.Text.Parsing.NonterminalParser(ToUtf32("PrimaryTypeExpr"), ToUtf32("PrimaryTypeExpr"), 1)), 
 9756                     new System.Text.Parsing.KleeneStarParser(
 9757                         new System.Text.Parsing.GroupingParser(
 9758                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9759                                 new System.Text.Parsing.CharParser('*')))))));
 9760             AddRule(new PrimaryTypeExprRule(ToUtf32("PrimaryTypeExpr"), GetScope(), Domain()->GetNextRuleId(), 
 9761                 new System.Text.Parsing.AlternativeParser(
 9762                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9763                         new System.Text.Parsing.NonterminalParser(ToUtf32("TypeId"), ToUtf32("TypeId"), 1)), 
 9764                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9765                         new System.Text.Parsing.NonterminalParser(ToUtf32("PrimitiveType"), ToUtf32("PrimitiveType"), 1)))));
 9766             AddRule(new TypeIdRule(ToUtf32("TypeId"), GetScope(), Domain()->GetNextRuleId(), 
 9767                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9768                     new System.Text.Parsing.TokenParser(
 9769                         new System.Text.Parsing.SequenceParser(
 9770                             new System.Text.Parsing.StringParser(ToUtf32("$T")), 
 9771                             new System.Text.Parsing.NonterminalParser(ToUtf32("uint"), ToUtf32("uint"), 0))))));
 9772             AddRule(new PrimitiveTypeRule(ToUtf32("PrimitiveType"), GetScope(), Domain()->GetNextRuleId(), 
 9773                 new System.Text.Parsing.AlternativeParser(
 9774                     new System.Text.Parsing.AlternativeParser(
 9775                         new System.Text.Parsing.AlternativeParser(
 9776                             new System.Text.Parsing.AlternativeParser(
 9777                                 new System.Text.Parsing.AlternativeParser(
 9778                                     new System.Text.Parsing.AlternativeParser(
 9779                                         new System.Text.Parsing.AlternativeParser(
 9780                                             new System.Text.Parsing.AlternativeParser(
 9781                                                 new System.Text.Parsing.AlternativeParser(
 9782                                                     new System.Text.Parsing.AlternativeParser(
 9783                                                         new System.Text.Parsing.AlternativeParser(
 9784                                                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9785                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("VoidType"), ToUtf32("VoidType"), 1)), 
 9786                                                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9787                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("BoolType"), ToUtf32("BoolType"), 1))), 
 9788                                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
 9789                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("SByteType"), ToUtf32("SByteType"), 1))), 
 9790                                                     new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
 9791                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ByteType"), ToUtf32("ByteType"), 1))), 
 9792                                                 new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
 9793                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ShortType"), ToUtf32("ShortType"), 1))), 
 9794                                             new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
 9795                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("UShortType"), ToUtf32("UShortType"), 1))), 
 9796                                         new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
 9797                                             new System.Text.Parsing.NonterminalParser(ToUtf32("IntType"), ToUtf32("IntType"), 1))), 
 9798                                     new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
 9799                                         new System.Text.Parsing.NonterminalParser(ToUtf32("UIntType"), ToUtf32("UIntType"), 1))), 
 9800                                 new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
 9801                                     new System.Text.Parsing.NonterminalParser(ToUtf32("LongType"), ToUtf32("LongType"), 1))), 
 9802                             new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
 9803                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ULongType"), ToUtf32("ULongType"), 1))), 
 9804                         new System.Text.Parsing.ActionParser(ToUtf32("A10"), 
 9805                             new System.Text.Parsing.NonterminalParser(ToUtf32("FloatType"), ToUtf32("FloatType"), 1))), 
 9806                     new System.Text.Parsing.ActionParser(ToUtf32("A11"), 
 9807                         new System.Text.Parsing.NonterminalParser(ToUtf32("DoubleType"), ToUtf32("DoubleType"), 1)))));
 9808             AddRule(new VoidTypeRule(ToUtf32("VoidType"), GetScope(), Domain()->GetNextRuleId(), 
 9809                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9810                     new System.Text.Parsing.KeywordParser(ToUtf32("void")))));
 9811             AddRule(new BoolTypeRule(ToUtf32("BoolType"), GetScope(), Domain()->GetNextRuleId(), 
 9812                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9813                     new System.Text.Parsing.KeywordParser(ToUtf32("bool")))));
 9814             AddRule(new SByteTypeRule(ToUtf32("SByteType"), GetScope(), Domain()->GetNextRuleId(), 
 9815                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9816                     new System.Text.Parsing.KeywordParser(ToUtf32("sbyte")))));
 9817             AddRule(new ByteTypeRule(ToUtf32("ByteType"), GetScope(), Domain()->GetNextRuleId(), 
 9818                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9819                     new System.Text.Parsing.KeywordParser(ToUtf32("byte")))));
 9820             AddRule(new ShortTypeRule(ToUtf32("ShortType"), GetScope(), Domain()->GetNextRuleId(), 
 9821                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9822                     new System.Text.Parsing.KeywordParser(ToUtf32("short")))));
 9823             AddRule(new UShortTypeRule(ToUtf32("UShortType"), GetScope(), Domain()->GetNextRuleId(), 
 9824                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9825                     new System.Text.Parsing.KeywordParser(ToUtf32("ushort")))));
 9826             AddRule(new IntTypeRule(ToUtf32("IntType"), GetScope(), Domain()->GetNextRuleId(), 
 9827                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9828                     new System.Text.Parsing.KeywordParser(ToUtf32("int")))));
 9829             AddRule(new UIntTypeRule(ToUtf32("UIntType"), GetScope(), Domain()->GetNextRuleId(), 
 9830                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9831                     new System.Text.Parsing.KeywordParser(ToUtf32("uint")))));
 9832             AddRule(new LongTypeRule(ToUtf32("LongType"), GetScope(), Domain()->GetNextRuleId(), 
 9833                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9834                     new System.Text.Parsing.KeywordParser(ToUtf32("long")))));
 9835             AddRule(new ULongTypeRule(ToUtf32("ULongType"), GetScope(), Domain()->GetNextRuleId(), 
 9836                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9837                     new System.Text.Parsing.KeywordParser(ToUtf32("ulong")))));
 9838             AddRule(new FloatTypeRule(ToUtf32("FloatType"), GetScope(), Domain()->GetNextRuleId(), 
 9839                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9840                     new System.Text.Parsing.KeywordParser(ToUtf32("float")))));
 9841             AddRule(new DoubleTypeRule(ToUtf32("DoubleType"), GetScope(), Domain()->GetNextRuleId(), 
 9842                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9843                     new System.Text.Parsing.KeywordParser(ToUtf32("double")))));
 9844             AddRule(new DataDefinitionRule(ToUtf32("DataDefinition"), GetScope(), Domain()->GetNextRuleId(), 
 9845                 new System.Text.Parsing.SequenceParser(
 9846                     new System.Text.Parsing.SequenceParser(
 9847                         new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1), 
 9848                         new System.Text.Parsing.ExpectationParser(
 9849                             new System.Text.Parsing.NonterminalParser(ToUtf32("name"), ToUtf32("identifier"), 0))), 
 9850                     new System.Text.Parsing.GroupingParser(
 9851                         new System.Text.Parsing.AlternativeParser(
 9852                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9853                                 new System.Text.Parsing.CharParser(';')), 
 9854                             new System.Text.Parsing.SequenceParser(
 9855                                 new System.Text.Parsing.ExpectationParser(
 9856                                     new System.Text.Parsing.CharParser('=')), 
 9857                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9858                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Constant"), ToUtf32("Constant"), 1))))))));
 9859             AddRule(new ConstantRule(ToUtf32("Constant"), GetScope(), Domain()->GetNextRuleId(), 
 9860                 new System.Text.Parsing.AlternativeParser(
 9861                     new System.Text.Parsing.AlternativeParser(
 9862                         new System.Text.Parsing.AlternativeParser(
 9863                             new System.Text.Parsing.AlternativeParser(
 9864                                 new System.Text.Parsing.AlternativeParser(
 9865                                     new System.Text.Parsing.AlternativeParser(
 9866                                         new System.Text.Parsing.AlternativeParser(
 9867                                             new System.Text.Parsing.AlternativeParser(
 9868                                                 new System.Text.Parsing.AlternativeParser(
 9869                                                     new System.Text.Parsing.AlternativeParser(
 9870                                                         new System.Text.Parsing.AlternativeParser(
 9871                                                             new System.Text.Parsing.AlternativeParser(
 9872                                                                 new System.Text.Parsing.AlternativeParser(
 9873                                                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9874                                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("BoolConstant"), ToUtf32("BoolConstant"), 1)), 
 9875                                                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9876                                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("SByteConstant"), ToUtf32("SByteConstant"), 1))), 
 9877                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
 9878                                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ByteConstant"), ToUtf32("ByteConstant"), 1))), 
 9879                                                             new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
 9880                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ShortConstant"), ToUtf32("ShortConstant"), 1))), 
 9881                                                         new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
 9882                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("UShortConstant"), ToUtf32("UShortConstant"), 1))), 
 9883                                                     new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
 9884                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("IntConstant"), ToUtf32("IntConstant"), 1))), 
 9885                                                 new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
 9886                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("UIntConstant"), ToUtf32("UIntConstant"), 1))), 
 9887                                             new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
 9888                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("LongConstant"), ToUtf32("LongConstant"), 1))), 
 9889                                         new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
 9890                                             new System.Text.Parsing.NonterminalParser(ToUtf32("ULongConstant"), ToUtf32("ULongConstant"), 1))), 
 9891                                     new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
 9892                                         new System.Text.Parsing.NonterminalParser(ToUtf32("FloatConstant"), ToUtf32("FloatConstant"), 1))), 
 9893                                 new System.Text.Parsing.ActionParser(ToUtf32("A10"), 
 9894                                     new System.Text.Parsing.NonterminalParser(ToUtf32("DoubleConstant"), ToUtf32("DoubleConstant"), 1))), 
 9895                             new System.Text.Parsing.ActionParser(ToUtf32("A11"), 
 9896                                 new System.Text.Parsing.NonterminalParser(ToUtf32("PtrConstant"), ToUtf32("PtrConstant"), 1))), 
 9897                         new System.Text.Parsing.ActionParser(ToUtf32("A12"), 
 9898                             new System.Text.Parsing.NonterminalParser(ToUtf32("ArrayConstant"), ToUtf32("ArrayConstant"), 1))), 
 9899                     new System.Text.Parsing.ActionParser(ToUtf32("A13"), 
 9900                         new System.Text.Parsing.NonterminalParser(ToUtf32("StructureConstant"), ToUtf32("StructureConstant"), 1)))));
 9901             AddRule(new BoolConstantRule(ToUtf32("BoolConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9902                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9903                     new System.Text.Parsing.GroupingParser(
 9904                         new System.Text.Parsing.SequenceParser(
 9905                             new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("BoolType"), 1), 
 9906                             new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("BoolValue"), 0))))));
 9907             AddRule(new BoolValueRule(ToUtf32("BoolValue"), GetScope(), Domain()->GetNextRuleId(), 
 9908                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9909                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("bool"), 0))));
 9910             AddRule(new SByteConstantRule(ToUtf32("SByteConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9911                 new System.Text.Parsing.SequenceParser(
 9912                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("SByteType"), 1), 
 9913                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9914                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("SByteValue"), 0)))));
 9915             AddRule(new SByteValueRule(ToUtf32("SByteValue"), GetScope(), Domain()->GetNextRuleId(), 
 9916                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9917                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("sbyte"), 0))));
 9918             AddRule(new ByteConstantRule(ToUtf32("ByteConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9919                 new System.Text.Parsing.SequenceParser(
 9920                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ByteType"), 1), 
 9921                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9922                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ByteValue"), 0)))));
 9923             AddRule(new ByteValueRule(ToUtf32("ByteValue"), GetScope(), Domain()->GetNextRuleId(), 
 9924                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9925                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("byte"), 0))));
 9926             AddRule(new ShortConstantRule(ToUtf32("ShortConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9927                 new System.Text.Parsing.SequenceParser(
 9928                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ShortType"), 1), 
 9929                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9930                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ShortValue"), 0)))));
 9931             AddRule(new ShortValueRule(ToUtf32("ShortValue"), GetScope(), Domain()->GetNextRuleId(), 
 9932                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9933                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("short"), 0))));
 9934             AddRule(new UShortConstantRule(ToUtf32("UShortConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9935                 new System.Text.Parsing.SequenceParser(
 9936                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("UShortType"), 1), 
 9937                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9938                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("UShortValue"), 0)))));
 9939             AddRule(new UShortValueRule(ToUtf32("UShortValue"), GetScope(), Domain()->GetNextRuleId(), 
 9940                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9941                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("ushort"), 0))));
 9942             AddRule(new IntConstantRule(ToUtf32("IntConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9943                 new System.Text.Parsing.SequenceParser(
 9944                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("IntType"), 1), 
 9945                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9946                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("IntValue"), 0)))));
 9947             AddRule(new IntValueRule(ToUtf32("IntValue"), GetScope(), Domain()->GetNextRuleId(), 
 9948                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9949                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("int"), 0))));
 9950             AddRule(new UIntConstantRule(ToUtf32("UIntConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9951                 new System.Text.Parsing.SequenceParser(
 9952                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("UIntType"), 1), 
 9953                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9954                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("UIntValue"), 0)))));
 9955             AddRule(new UIntValueRule(ToUtf32("UIntValue"), GetScope(), Domain()->GetNextRuleId(), 
 9956                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9957                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))));
 9958             AddRule(new LongConstantRule(ToUtf32("LongConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9959                 new System.Text.Parsing.SequenceParser(
 9960                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("LongType"), 1), 
 9961                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9962                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("LongValue"), 0)))));
 9963             AddRule(new LongValueRule(ToUtf32("LongValue"), GetScope(), Domain()->GetNextRuleId(), 
 9964                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9965                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("long"), 0))));
 9966             AddRule(new ULongConstantRule(ToUtf32("ULongConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9967                 new System.Text.Parsing.SequenceParser(
 9968                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ULongType"), 1), 
 9969                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9970                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ULongValue"), 0)))));
 9971             AddRule(new ULongValueRule(ToUtf32("ULongValue"), GetScope(), Domain()->GetNextRuleId(), 
 9972                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9973                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("ulong"), 0))));
 9974             AddRule(new FloatConstantRule(ToUtf32("FloatConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9975                 new System.Text.Parsing.SequenceParser(
 9976                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("FloatType"), 1), 
 9977                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9978                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("FloatValue"), 0)))));
 9979             AddRule(new FloatValueRule(ToUtf32("FloatValue"), GetScope(), Domain()->GetNextRuleId(), 
 9980                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9981                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("float"), 0))));
 9982             AddRule(new DoubleConstantRule(ToUtf32("DoubleConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9983                 new System.Text.Parsing.SequenceParser(
 9984                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("DoubleType"), 1), 
 9985                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9986                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("DoubleValue"), 0)))));
 9987             AddRule(new DoubleValueRule(ToUtf32("DoubleValue"), GetScope(), Domain()->GetNextRuleId(), 
 9988                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9989                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("double"), 0))));
 9990             AddRule(new PtrConstantRule(ToUtf32("PtrConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9991                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
 9992                     new System.Text.Parsing.GroupingParser(
 9993                         new System.Text.Parsing.SequenceParser(
 9994                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
 9995                                 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1)), 
 9996                             new System.Text.Parsing.KeywordParser(ToUtf32("null")))))));
 9997             AddRule(new ArrayConstantRule(ToUtf32("ArrayConstant"), GetScope(), Domain()->GetNextRuleId(), 
 9998                 new System.Text.Parsing.SequenceParser(
 9999                     new System.Text.Parsing.SequenceParser(
10000                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10001                             new System.Text.Parsing.CharParser('[')), 
10002                         new System.Text.Parsing.OptionalParser(
10003                             new System.Text.Parsing.GroupingParser(
10004                                 new System.Text.Parsing.ListParser(
10005                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
10006                                         new System.Text.Parsing.NonterminalParser(ToUtf32("element"), ToUtf32("Constant"), 1)), 
10007                                     new System.Text.Parsing.CharParser(','))))), 
10008                     new System.Text.Parsing.CharParser(']'))));
10009             AddRule(new StructureConstantRule(ToUtf32("StructureConstant"), GetScope(), Domain()->GetNextRuleId(), 
10010                 new System.Text.Parsing.SequenceParser(
10011                     new System.Text.Parsing.SequenceParser(
10012                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10013                             new System.Text.Parsing.CharParser('{')), 
10014                         new System.Text.Parsing.OptionalParser(
10015                             new System.Text.Parsing.GroupingParser(
10016                                 new System.Text.Parsing.ListParser(
10017                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
10018                                         new System.Text.Parsing.NonterminalParser(ToUtf32("member"), ToUtf32("Constant"), 1)), 
10019                                     new System.Text.Parsing.CharParser(','))))), 
10020                     new System.Text.Parsing.CharParser('}'))));
10021             SetSkipRuleName(ToUtf32("spaces"));
10022         }
10023         private List<ustring> keywords0;
10024     }
10025 } // cmsx.intermediate